home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 52 / Amiga Format AFCD52 (Issue 136, May 2000).iso / -serious- / programming / other / systracker_src / src / st_artl.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-28  |  80.8 KB  |  3,048 lines
  1. /***************************************************************************/
  2. /* st_artl.c - The Application Resource Tracker List (ARTL).               */
  3. /*                                                                         */
  4. /* Copyright © 1999-2000 Andrew Bell. All rights reserved.                 */
  5. /***************************************************************************/
  6.  
  7. #include "SysTracker_rev.h"
  8. #include "st_include.h"
  9. #include "st_protos.h"
  10. #include "st_strings.h"
  11.  
  12. /***************************************************************************/
  13. /* Data and defines */
  14. /***************************************************************************/
  15.  
  16. ULONG ARTL_TrackMode = TRACKMODE_LIBRARIES; /* Default */
  17. struct AppList *ARTL = NULL;
  18.  
  19. /* SysTracker <-> ATRL-Handler IPC */
  20.  
  21. BYTE ARTLInitSig_Running         = -1; /* Child process is running OK. */
  22. ULONG ARTLInitSigMask_Running    = 0;
  23. BYTE ARTLInitSig_NotRunning      = -1; /* Child process failed to start.  */
  24. ULONG ARTLInitSigMask_NotRunning = 0;
  25.  
  26. struct Process *ARTLProcess = NULL;
  27. struct MsgPort *ARTLProcessPort = NULL;
  28.  
  29. struct ARTLProcessMsg /* aka APM */
  30. {
  31.   struct Message apm_Msg;
  32.   LONG           apm_CmdID;
  33. };
  34.  
  35. enum /* The command set is fairly basic atm. */
  36. {
  37.   APM_CMDID_NOP = 0,
  38.   APM_CMDID_QUIT
  39. };
  40.  
  41. /***************************************************************************/
  42.  
  43. GPROTO BOOL ARTL_Init( void )
  44. {
  45.   /*********************************************************************
  46.    *
  47.    * ARTL_Init()
  48.    *
  49.    * This routine is called by the main SysTracker process. It is
  50.    * responsible for allocating all IPC related resources and invoking
  51.    * the ARTL handler (child) process. It will return TRUE for success
  52.    * else FALSE for failure.
  53.    *
  54.    *********************************************************************
  55.    *
  56.    */
  57.  
  58.   ARTLInitSig_Running = AllocSignal(-1);
  59.   if (ARTLInitSig_Running == -1) return FALSE;
  60.   ARTLInitSig_NotRunning = AllocSignal(-1);
  61.   if (ARTLInitSig_NotRunning == -1) return FALSE;
  62.  
  63.   /* Create the signal masks */
  64.  
  65.   ARTLInitSigMask_Running     = (1 << ARTLInitSig_Running);
  66.   ARTLInitSigMask_NotRunning  = (1 << ARTLInitSig_NotRunning);
  67.  
  68.   /* Some defines that will be moved to a header file later. */
  69.   
  70.   #define ARTL_PROCESS_NAME      "SysTracker's ARTL Handler"
  71.   #define ARTL_PROCESS_PRIORITY  -1
  72.   #define ARTL_PROCESS_STACKSIZE (1024 * 16)
  73.  
  74.   if (ARTLProcess = CreateNewProcTags(
  75.                       NP_StackSize, ARTL_PROCESS_STACKSIZE,
  76.                       NP_Name,      ARTL_PROCESS_NAME,
  77.                       NP_Priority,  ARTL_PROCESS_PRIORITY,
  78.                       NP_Entry,     &ARTL_HandlerProcess,
  79.                       TAG_DONE))
  80.   {
  81.     register ULONG SigsGot = 0;
  82.  
  83.     SigsGot = Wait(SIGBREAKF_CTRL_C |
  84.                    ARTLInitSigMask_Running |
  85.                    ARTLInitSigMask_NotRunning);
  86.  
  87.     if (SigsGot & ARTLInitSigMask_Running)    
  88.     {
  89.       /* OK, The process says it's running, if this is the
  90.          case then initialization was successful. Continue on
  91.          as normal. ARTLProcessPort will be valid. */
  92.     }
  93.     else if ((SigsGot & ARTLInitSigMask_NotRunning) ||
  94.              (SigsGot & SIGBREAKF_CTRL_C))
  95.     {
  96.       /* The process says it's going to quit, if this is the
  97.          case then initialization was not successful. */
  98.  
  99.       ARTLProcess = NULL;
  100.       return FALSE;
  101.     }
  102.   }
  103.   else return FALSE;
  104.  
  105.   return TRUE;
  106. }
  107.  
  108. GPROTO BOOL ARTL_Free( void )
  109. {
  110.   /*********************************************************************
  111.    *
  112.    * ARTL_Free()
  113.    *
  114.    * This routine will attempt to quit the ARTL process and free all
  115.    * allocated IPC related resources. It returns TRUE on success else
  116.    * FALSE on failure. Typically FALSE is returned when the ARTL
  117.    * handler process can't remove it's patches from the system.
  118.    *
  119.    *********************************************************************
  120.    *
  121.    */
  122.  
  123.   if (ARTLProcess && ARTLProcessPort)
  124.   {
  125.     register ULONG SigsGot = 0;
  126.  
  127.     if (!ARTL_SendSimpleAPMCmd(APM_CMDID_QUIT))
  128.       return FALSE;
  129.  
  130.     SigsGot = Wait(SIGBREAKF_CTRL_C |
  131.                    ARTLInitSigMask_Running |
  132.                    ARTLInitSigMask_NotRunning);
  133.  
  134.     if (SigsGot & ARTLInitSigMask_Running)
  135.     {
  136.       /* The process can't quit, probably because it can't remove
  137.          the patches. If this is the case then return FALSE, this will
  138.          make SysTracker go back into it's main loop. */
  139.  
  140.       return FALSE;
  141.     }
  142.     else if ((SigsGot & ARTLInitSigMask_NotRunning) ||
  143.              (SigsGot & SIGBREAKF_CTRL_C))
  144.     {
  145.       ARTLProcess = NULL;
  146.     }
  147.   }
  148.  
  149.   /* Free the signals */
  150.  
  151.   if (ARTLInitSig_Running != -1)
  152.   {
  153.     FreeSignal(ARTLInitSig_Running); ARTLInitSig_Running = -1;
  154.   }
  155.  
  156.   if (ARTLInitSig_NotRunning != -1)
  157.   {
  158.     FreeSignal(ARTLInitSig_NotRunning); ARTLInitSig_NotRunning = -1;
  159.   }
  160. }
  161.  
  162. GPROTO BOOL ARTL_SendSimpleAPMCmd( LONG CmdID )
  163. {
  164.   /*********************************************************************
  165.    *
  166.    * ARTL_SendSimpleAPMCmd()
  167.    *
  168.    * Send a simple command to the ARTL-Handler that requires no
  169.    * parameters. 
  170.    *
  171.    *********************************************************************
  172.    *
  173.    */
  174.  
  175.   struct ARTLProcessMsg APM;
  176.   memset(&APM, 0, sizeof(struct ARTLProcessMsg));
  177.   APM.apm_CmdID = CmdID;
  178.   return ARTL_SendAPM(&APM)
  179. }
  180.  
  181. GPROTO BOOL ARTL_SendAPM( struct ARTLProcessMsg *APM )
  182. {
  183.   /*********************************************************************
  184.    *
  185.    * ARTL_SendAPM()
  186.    *
  187.    * Send an ARTLProcessMsg to the ARTL-Handler process. This routine
  188.    * does all the dirty work like setting up the message header.
  189.    *
  190.    *********************************************************************
  191.    *
  192.    */
  193.  
  194.   struct MsgPort *TmpReplyPort = NULL;  
  195.   if (!APM || !ARTLProcessPort) return FALSE;
  196.  
  197.   if (TmpReplyPort = CreateMsgPort())
  198.   {
  199.     APM->apm_Msg.mn_Node.ln_Type = NT_MESSAGE;
  200.     APM->apm_Msg.mn_Length       = sizeof(struct ARTLProcessMsg);
  201.     APM->apm_Msg.mn_ReplyPort    = TmpReplyPort;
  202.     PutMsg(ARTLProcessPort, (struct Message *)APM);
  203.     Wait(1UL << TmpReplyPort->mp_SigBit);
  204.     DeleteMsgPort(TmpReplyPort);
  205.     return TRUE;
  206.   }
  207.   return FALSE;
  208. }
  209.  
  210. GPROTO struct AppList *ARTL_GetAppList( void )
  211. {
  212.   return ARTL;
  213. }
  214.  
  215. GPROTO void ARTL_Set_TrackMode( ULONG NewTrackMode )
  216. {
  217.   ARTL_TrackMode = NewTrackMode;
  218. }
  219.  
  220. GPROTO ULONG ARTL_Get_TrackMode( void )
  221. {
  222.   return ARTL_TrackMode;
  223. }
  224.  
  225. GPROTO BOOL ARTL_CheckProcSignals( ULONG SigsGot )
  226. {
  227.   /*********************************************************************
  228.    *
  229.    * ARTL_CheckProcSignals()
  230.    *
  231.    * This routine is called by the main SysTracker task when it receives
  232.    * some signals. This routine handles all of the ARTL process related
  233.    * signals. TRUE will be returned if SysTracker must quit.
  234.    *
  235.    *********************************************************************
  236.    *
  237.    */
  238.       
  239.   if (SigsGot & ARTLInitSigMask_NotRunning)
  240.   {
  241.     /* If we get this signal we must assume that something
  242.        has went wrong. */
  243.  
  244.     ARTLProcess = NULL; /* So ARTL_Free() knows the process is dead. */
  245.     return TRUE;
  246.   } 
  247.   return FALSE;
  248. }
  249.  
  250. /* ARTL handler process variables
  251.    ------------------------------
  252.    The ARTL AppList pointer belongs to the ARTL handler process,
  253.    and can *only* be access after the main SysTracker has received
  254.    the ARTLInitSig_Running signal. */
  255.  
  256. struct MsgPort *PatchPort = NULL;
  257. ULONG PMsgCnt = 0;
  258. BPTR DebugFH = 0;
  259.  
  260. GPROTO ULONG ARTL_GetPMsgCnt( void )
  261. {
  262.   return PMsgCnt;
  263. }
  264.  
  265. LPROTO LONG ARTL_HandlerProcess( void )
  266. {
  267.   /*********************************************************************
  268.    *
  269.    * ARTL_HandlerProc_Entry()
  270.    *
  271.    * This entire sub routine is an independent process that is launched
  272.    * by the main SysTracker process. This process is responsible for
  273.    * handling the PatchMsgs that arrive at the PatchPort, updating the
  274.    * main AppList tree per message. Because a constant stream of
  275.    * PatchMsgs may be arriving at the port, we use an independent
  276.    * process to handle the messages. This frees up the main SysTracker
  277.    * process, so it can handle the user's input, etc.
  278.    *
  279.    *********************************************************************
  280.    *
  281.    */
  282.  
  283.   /* Note: SysTracker is always compiled under a large code model, so
  284.            doesn't require A4 to be setup. */
  285.  
  286.   BOOL Success = FALSE; /* Assume failure */
  287.  
  288.   if (ATRL_InitHandlerDebug())
  289.   {
  290.     if ((PatchPort = CreateMsgPort()) &&
  291.         (ARTLProcessPort = CreateMsgPort()))
  292.     {
  293.       ULONG PatchPort_SigMask = 1UL << PatchPort->mp_SigBit;
  294.       ULONG ARTLProcessPort_SigMask = 1UL << ARTLProcessPort->mp_SigBit;
  295.       register struct PatchMsg *PMsg = NULL;
  296.       register struct ARTLProcessMsg *APM = NULL;
  297.  
  298.       if (ARTL = ARTL_AllocAL())
  299.       {
  300.         if (PATCH_Init())
  301.         {
  302.           Success = TRUE;
  303.           Signal((struct Task *)SysTrackerProcess, ARTLInitSigMask_Running);
  304.  
  305.           for (;;)
  306.           {
  307.             BOOL Running = TRUE;
  308.             ULONG SigEvent = 0;
  309.  
  310.             while (Running)
  311.             {
  312.               SigEvent = Wait(PatchPort_SigMask | ARTLProcessPort_SigMask);
  313.  
  314.               if (SigEvent & PatchPort_SigMask)
  315.               {
  316.                 while (PMsg =
  317.                    (struct PatchMsg *) GetMsg((struct MsgPort *) PatchPort))
  318.                 {                 
  319.                   PMsgCnt += 1;
  320.                   if (cfg_DebugMode) ARTL_PMsgDebug(PMsg);
  321.  
  322.                   switch(PMsg->pmsg_ID)
  323.                   {
  324.                     case PMSGID_OPENLIBRARY:
  325.                       ARTL_PushLibAN( ARTL, PMsg ); break;
  326.                     case PMSGID_CLOSELIBRARY:
  327.                       ARTL_PullLibAN( ARTL, PMsg ); break;
  328.                     case PMSGID_OPENDEVICE:
  329.                       ARTL_PushDevAN( ARTL, PMsg ); break;
  330.                     case PMSGID_CLOSEDEVICE:
  331.                       ARTL_PullDevAN( ARTL, PMsg ); break;
  332.                     case PMSGID_OPENFONT:
  333.                       ARTL_PushFontAN( ARTL, PMsg ); break;
  334.                     case PMSGID_CLOSEFONT:
  335.                       ARTL_PullFontAN( ARTL, PMsg ); break;
  336.                     case PMSGID_LOCK:
  337.                       ARTL_PushLockAN( ARTL, PMsg ); break;
  338.                     case PMSGID_UNLOCK:
  339.                       ARTL_PullLockAN( ARTL, PMsg ); break;
  340.                     case PMSGID_OPEN:
  341.                       ARTL_PushFileHandleAN( ARTL, PMsg ); break;
  342.                     case PMSGID_CLOSE:
  343.                       ARTL_PullFileHandleAN( ARTL, PMsg ); break;
  344.                     case PMSGID_OPENFROMLOCK:
  345.                       ARTL_PushFileHandleAN( ARTL, PMsg ); break;
  346.                     default: break;
  347.                   }
  348.  
  349.                   PATCH_DeletePatchMsg(PMsg);
  350.                 } /* while () */
  351.                 /* REMOVED: if (cfg_AutoUpdate) ACT_Main_Update();*/
  352.               }
  353.  
  354.               if (SigEvent & ARTLProcessPort_SigMask)
  355.               {
  356.                 /* The main ARTL process is communicating with us. */               
  357.  
  358.                 while (APM = (struct ARTLProcessMsg *) GetMsg(ARTLProcessPort))
  359.                 {
  360.                   switch(APM->apm_CmdID)
  361.                   {
  362.                     default:
  363.                     case APM_CMDID_NOP: break;
  364.                     case APM_CMDID_QUIT: Running = FALSE; break;
  365.                   }
  366.                   ReplyMsg((struct Message *)APM);
  367.                 }
  368.               }
  369.             } /* while () */
  370.  
  371.             if (PATCH_Free()) break;
  372.             else Signal((struct Task *)SysTrackerProcess,
  373.                   ARTLInitSigMask_Running);
  374.  
  375.           } /* for (;;) */                
  376.         }
  377.         ARTL_FreeAL(ARTL); ARTL = NULL;
  378.       }
  379.  
  380.       /* Free any pending messages on the PatchPort */  
  381.       while (PMsg = (struct PatchMsg *) GetMsg( (struct MsgPort *) PatchPort))
  382.         PATCH_DeletePatchMsg(PMsg);
  383.     }
  384.  
  385.     if (PatchPort)
  386.       DeletePort(PatchPort); PatchPort = NULL;
  387.  
  388.     if (ARTLProcessPort)
  389.       DeletePort(ARTLProcessPort); ARTLProcessPort = NULL;
  390.   }
  391.   ATRL_EndHandlerDebug();
  392.   ARTLProcess = NULL;
  393.  
  394.   Signal((struct Task *) SysTrackerProcess, ARTLInitSigMask_NotRunning);
  395.   return RETURN_OK;
  396. }
  397.  
  398. LPROTO BOOL ATRL_InitHandlerDebug( void )
  399. {
  400.   /*********************************************************************
  401.    *
  402.    * ATRL_InitHandlerDebug()
  403.    *
  404.    * Allocate the handler debugging resources.
  405.    *
  406.    *********************************************************************
  407.    *
  408.    */
  409.  
  410.   #define DEBUG_DEST "CON:0/11/640/60/ARTL_Handler_Debug_window/CLOSE"
  411.   /*#define DEBUG_DEST "Ram:SysTracker_debug.log"*/
  412.  
  413.   if (!cfg_DebugMode) return TRUE;
  414.   if (!(DebugFH = Open(DEBUG_DEST , MODE_NEWFILE))) return FALSE;
  415.  
  416.   return TRUE;
  417. }
  418.  
  419. LPROTO void ATRL_EndHandlerDebug( void )
  420. {
  421.   /*********************************************************************
  422.    *
  423.    * ATRL_EndHandlerDebug()
  424.    *
  425.    * Free the handler debugging resources.
  426.    *
  427.    *********************************************************************
  428.    *
  429.    */
  430.   
  431.   if (!cfg_DebugMode) return;
  432.   if (DebugFH)
  433.   {
  434.     Close(DebugFH); DebugFH = 0;
  435.   }
  436. }
  437.  
  438. LPROTO void ARTL_PMsgDebug( struct PatchMsg *PMsg )
  439. {
  440.   /*********************************************************************
  441.    *
  442.    * ARTL_PMsgDebug()
  443.    *
  444.    * Print some debug information about a PatchMsg structure.
  445.    *
  446.    *********************************************************************
  447.    *
  448.    */
  449.  
  450.   register UBYTE *LVOName = NULL;
  451.   register UBYTE *AppName = NULL;
  452.   struct AppNode *AN = NULL;
  453.   struct TrackerNode *TN =  NULL;
  454.  
  455.   if (!PMsg) return;
  456.  
  457.   AppName =
  458.      (PMsg->pmsg_CmdName ? PMsg->pmsg_CmdName : PMsg->pmsg_TaskName);
  459.  
  460.   if (!AppName || strlen(AppName) == 0) AppName = "(Unnamed task)";
  461.  
  462.   ARTL_LockAL(ARTL);
  463.  
  464.   AN = ARTL_FindAN_ViaTaskPtr(ARTL, PMsg->pmsg_TaskPtr);
  465.  
  466.   switch(PMsg->pmsg_ID)
  467.   {
  468.     case PMSGID_OPENLIBRARY:
  469.       FPrintf(DebugFH, "%-010.010s OpenLibrary(\"%s\", %ld)\n",
  470.         AppName, PMsg->pmsg_LibName, PMsg->pmsg_LibVer);
  471.       break;
  472.  
  473.     case PMSGID_OPENDEVICE:
  474.       FPrintf(DebugFH,
  475.         "%-010.010s OpenDevice(\"%s\", %ld, 0x%08lx, 0x%08lx)\n",
  476.         AppName, PMsg->pmsg_DevName,
  477.         PMsg->pmsg_DevUnitNum, PMsg->pmsg_DevIOReq, PMsg->pmsg_DevFlags);
  478.       break;
  479.  
  480.     case PMSGID_CLOSELIBRARY:
  481.       if (AN)
  482.       {
  483.         TN = ARTL_FindLibTN_ViaLibBase(
  484.           (struct List *) &AN->an_TrackerList, PMsg->pmsg_LibBase);
  485.       }
  486.       FPrintf(DebugFH,
  487.         "%-010.010s CloseLibrary($%08lx) [%s] AN=$%08lx TN=$%08lx\n",
  488.         AppName, PMsg->pmsg_LibBase, PMsg->pmsg_LibName, AN, TN);
  489.       break;
  490.  
  491.     case PMSGID_CLOSEDEVICE:
  492.       if (AN)
  493.       {
  494.         TN = ARTL_FindDevTN_ViaIOReq(
  495.           (struct List *) &AN->an_TrackerList, PMsg->pmsg_DevIOReq);
  496.       }
  497.       FPrintf(DebugFH,
  498.         "%-010.010s CloseDevice($%08lx) [%s] AN=$%08lx TN=$%08lx\n",
  499.         AppName, PMsg->pmsg_DevIOReq,
  500.         (TN ? TN->tn_DevName : "???"), AN, TN);
  501.       break;
  502.  
  503.     case PMSGID_OPENFONT:
  504.       FPrintf(DebugFH,
  505.         "%-010.010s OpenFont($%08lx) [%s/%ld]\n",
  506.         AppName, PMsg->pmsg_FontTextAttr,
  507.         PMsg->pmsg_FontName, (LONG) PMsg->pmsg_FontYSize);
  508.       break;
  509.  
  510.     case PMSGID_CLOSEFONT:
  511.       if (AN)
  512.       {
  513.         TN = ARTL_FindFontTN_ViaTextFont(
  514.           (struct List *) &AN->an_TrackerList, PMsg->pmsg_FontTextFont);
  515.       }
  516.       FPrintf(DebugFH,
  517.         "%-010.010s CloseFont($%08lx) [%s] AN=$%08lx TN=$%08lx\n",
  518.         AppName, PMsg->pmsg_FontTextFont,
  519.         (TN ? TN->tn_FontName : "???"), AN, TN);
  520.       break;
  521.  
  522.     case PMSGID_OPEN:
  523.       FPrintf(DebugFH,
  524.         "%-010.010s Open(%.256s,%ld) [FH=$%08lx]\n",
  525.         AppName, PMsg->pmsg_FHName, PMsg->pmsg_FHMode, PMsg->pmsg_FH);
  526.       break;
  527.  
  528.     case PMSGID_CLOSE:
  529.       FPrintf(DebugFH,
  530.         "%-010.010s Close($%08lx)\n",
  531.         AppName, PMsg->pmsg_FH);
  532.       break;
  533.  
  534.     case PMSGID_OPENFROMLOCK:
  535.       FPrintf(DebugFH,
  536.         "%-010.010s OpenFromLock($%08lx) [FH=$%08lx]\n",
  537.         AppName, PMsg->pmsg_Lock, PMsg->pmsg_Lock);
  538.       break;
  539.  
  540.     case PMSGID_LOCK:
  541.       FPrintf(DebugFH,
  542.         "%-010.010s Lock(%.256s,%ld) [LOCK=$%08lx]\n",
  543.         AppName, PMsg->pmsg_LockName,
  544.         PMsg->pmsg_LockMode, PMsg->pmsg_Lock);
  545.       break;
  546.  
  547.     case PMSGID_UNLOCK:
  548.       FPrintf(DebugFH,
  549.         "%-010.010s UnLock($%08lx)\n",
  550.         AppName, PMsg->pmsg_Lock);
  551.       break;
  552.  
  553.     default:
  554.       LVOName = "???";
  555.       break;
  556.   }
  557.   ARTL_UnlockAL(ARTL);
  558. }
  559.  
  560. LPROTO struct AppNode *ARTL_PushLibAN( struct AppList *AL,
  561.   struct PatchMsg *PMsg )
  562. { 
  563.   /*********************************************************************
  564.    *
  565.    * ARTL_PushLibAN()
  566.    *
  567.    * Append a library AppNode onto the main AppList (ARTL).
  568.    *
  569.    *********************************************************************
  570.    *
  571.    */
  572.  
  573.   register struct AppNode *AN;
  574.   register struct TrackerNode *TN;
  575.  
  576.   if (!PMsg->pmsg_LibBase) return NULL;
  577.  
  578.   ARTL_LockAL(AL);
  579.  
  580.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  581.   {       
  582.     /* OK, we're already tracking this App. We must now determine
  583.        if the library it's attempting to open is already on the
  584.        AppNode's TrackerNode list. If so, update the open count of
  585.        the existing TrackerNode else allocate a fresh TrackerNode. */
  586.  
  587.     if (TN = ARTL_FindLibTN_ViaLibName(
  588.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_LibName))
  589.       TN->tn_OpenCnt += 1;
  590.     else if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  591.       ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList, ADDMODE_APPEND);
  592.     
  593.     /* Correct/update the task/process names. This comes in handy
  594.        if the application changes it's task/process name on the fly. */
  595.  
  596.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  597.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName);    
  598.   } 
  599.   else if (AN = ARTL_CreateAN_ViaPMsg(PMsg))
  600.   {
  601.     /* At this point we've determined that the App is not being tracked,
  602.        because no AppNode exists for it. So we create one, using the
  603.        information found in the PatchMsg. Then link it onto the AppList. */
  604.     
  605.       ARTL_AddANToAL(AN, AL);
  606.   }
  607.   ARTL_UnlockAL(AL);
  608.   return AN;
  609. }
  610.  
  611. LPROTO void ARTL_PullLibAN( struct AppList *AL, struct PatchMsg *PMsg )
  612. {
  613.   /*********************************************************************
  614.    *
  615.    * ARTL_PullLibAN()
  616.    *
  617.    * Remove a library AppNode from the main AppList (ARTL).
  618.    *
  619.    *********************************************************************
  620.    *
  621.    */
  622.  
  623.   register struct AppNode *AN;
  624.  
  625.   ARTL_LockAL(AL);
  626.  
  627.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  628.   {
  629.     /* Now that we've found the AppNode associated with this call
  630.        to CloseLibrary(), we must scan the TrackerNode list for
  631.        the library that it's attempting to close. Once we find it,
  632.        we subtract it's open count, when this becomes zero, we can
  633.        unlink and delete it. If the TrackerNode list becomes empty,
  634.        then we can unlink and delete the AppNode also. */
  635.  
  636.     register struct TrackerNode *TN;
  637.  
  638.     if (PMsg->pmsg_LibBase)
  639.       TN = ARTL_FindLibTN_ViaLibBase(
  640.             (struct List *) &AN->an_TrackerList, PMsg->pmsg_LibBase);
  641.     else /* Find it by name */
  642.       TN = ARTL_FindLibTN_ViaLibName(
  643.             (struct List *) &AN->an_TrackerList, PMsg->pmsg_LibName);
  644.  
  645.     if (TN)
  646.     {     
  647.       TN->tn_OpenCnt -= 1;
  648.       
  649.       if (TN->tn_OpenCnt <= 0)
  650.       {
  651.         /* When the TrackerNode's open count becomes zero, we can mark
  652.            it as unused. But only if cfg_TrackResNotInUse is TRUE else
  653.            we delete the TrackerNode altogether. */
  654.  
  655.         if (cfg_TrackUnusedResources)
  656.         {
  657.           TN->tn_InUse = FALSE;
  658.  
  659.           if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  660.           {
  661.             /* If this AppNode has freed all of it's resources then
  662.                remove the AppNode. */
  663.  
  664.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  665.           }
  666.         }
  667.         else /* Kill off the TrackerNode */
  668.         {
  669.           ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  670.  
  671.           if (ARTL_CountTL(&AN->an_TrackerList, PMSGID_ALL) == 0)
  672.           {
  673.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  674.           }
  675.         }       
  676.       }
  677.     }
  678.   }
  679.   ARTL_UnlockAL(AL);
  680. }
  681.  
  682. LPROTO struct AppNode *ARTL_PushDevAN( struct AppList *AL,
  683.   struct PatchMsg *PMsg )
  684. {
  685.   /*********************************************************************
  686.    *
  687.    * ARTL_PushDevAN()
  688.    *
  689.    * Append a device AppNode onto the main AppList (ARTL).
  690.    *
  691.    *********************************************************************
  692.    *
  693.    */
  694.  
  695.   register struct AppNode *AN;
  696.   register struct TrackerNode *TN;
  697.  
  698.   if (!PMsg->pmsg_DevIOReq) return NULL;
  699.  
  700.   ARTL_LockAL(AL);
  701.  
  702.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  703.   {           
  704.     if (TN = ARTL_FindDevTN_ViaIOReq(
  705.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_DevIOReq))
  706.       TN->tn_OpenCnt += 1;
  707.     else if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  708.       ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList, ADDMODE_APPEND);
  709.  
  710.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  711.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName);    
  712.   } 
  713.   else if (AN = ARTL_CreateAN_ViaPMsg(PMsg))
  714.     ARTL_AddANToAL(AN, AL);
  715.   
  716.   ARTL_UnlockAL(AL);
  717.  
  718.   return AN;
  719. }
  720.  
  721. LPROTO void ARTL_PullDevAN( struct AppList *AL, struct PatchMsg *PMsg )
  722. {
  723.   /*********************************************************************
  724.    *
  725.    * ARTL_PullDevAN()
  726.    *
  727.    * Remove a library AppNode from the main AppList (ARTL).
  728.    *
  729.    *********************************************************************
  730.    *
  731.    */
  732.  
  733.   register struct AppNode *AN;
  734.   register struct TrackerNode *TN;
  735.  
  736.   ARTL_LockAL(AL);
  737.  
  738.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  739.   {
  740.     if (TN = ARTL_FindDevTN_ViaIOReq(
  741.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_DevIOReq))
  742.     {     
  743.       TN->tn_OpenCnt -= 1;
  744.       
  745.       if (TN->tn_OpenCnt <= 0)
  746.       {
  747.         if (cfg_TrackUnusedResources)
  748.         {
  749.           TN->tn_InUse = FALSE;
  750.  
  751.           if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  752.           {
  753.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  754.           }
  755.         }
  756.         else /* Kill off the TrackerNode */
  757.         {
  758.           ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  759.  
  760.           if (ARTL_CountTL(&AN->an_TrackerList, PMSGID_ALL) == 0)
  761.           {
  762.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  763.           }
  764.         }       
  765.       }
  766.     }
  767.   }
  768.   ARTL_UnlockAL(AL);
  769. }
  770.  
  771. LPROTO struct AppNode *ARTL_PushFontAN( struct AppList *AL,
  772.   struct PatchMsg *PMsg )
  773. {
  774.   /*********************************************************************
  775.    *
  776.    * ARTL_PushFontAN()
  777.    *
  778.    *********************************************************************
  779.    *
  780.    */
  781.  
  782.   register struct AppNode *AN;
  783.  
  784.   if (!PMsg->pmsg_FontTextFont) return NULL;
  785.  
  786.   ARTL_LockAL(AL);
  787.  
  788.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  789.   {       
  790.     register struct TrackerNode *TN;
  791.  
  792.     if (TN = ARTL_FindFontTN_ViaTextFont(
  793.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_FontTextFont))
  794.       TN->tn_OpenCnt += 1;
  795.     else if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  796.       ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList, ADDMODE_APPEND);
  797.  
  798.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  799.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName);    
  800.   } 
  801.   else if (AN = ARTL_CreateAN_ViaPMsg(PMsg))
  802.     ARTL_AddANToAL(AN, AL);
  803.  
  804.   ARTL_UnlockAL(AL);
  805.   return AN;
  806. }
  807.  
  808. LPROTO void ARTL_PullFontAN( struct AppList *AL, struct PatchMsg *PMsg )
  809. {
  810.   /*********************************************************************
  811.    *
  812.    * ARTL_PullFontAN()
  813.    *
  814.    *********************************************************************
  815.    *
  816.    */
  817.  
  818.   register struct AppNode *AN;
  819.   register struct TrackerNode *TN;
  820.  
  821.   /* We're not interested in OpenFont()/OpenDiskFont() failures. */
  822.  
  823.   if (!PMsg->pmsg_FontTextFont) return;
  824.  
  825.   ARTL_LockAL(AL);
  826.  
  827.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  828.   {
  829.     if (TN = ARTL_FindFontTN_ViaTextFont(
  830.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_FontTextFont))
  831.     {     
  832.       TN->tn_OpenCnt -= 1;      
  833.  
  834.       if (TN->tn_OpenCnt <= 0)
  835.       {
  836.         if (cfg_TrackUnusedResources)
  837.         {
  838.           TN->tn_InUse = FALSE;
  839.  
  840.           if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  841.           {
  842.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  843.           }
  844.         }
  845.         else /* Kill off the TrackerNode */
  846.         {
  847.           ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  848.  
  849.           if (ARTL_CountTL(&AN->an_TrackerList, PMSGID_ALL) == 0)
  850.           {
  851.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  852.           }
  853.         }       
  854.       }
  855.     }
  856.   } 
  857.   ARTL_UnlockAL(AL);
  858. }
  859.  
  860. LPROTO struct AppNode *ARTL_PushLockAN( struct AppList *AL,
  861.   struct PatchMsg *PMsg )
  862. {
  863.   /*********************************************************************
  864.    *
  865.    * ARTL_PushLockAN()
  866.    *
  867.    *********************************************************************
  868.    *
  869.    */
  870.  
  871.   register struct AppNode *AN;
  872.   register struct TrackerNode *TN;
  873.  
  874.   if (!PMsg->pmsg_Lock) return NULL;
  875.  
  876.   ARTL_LockAL(AL);
  877.  
  878.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  879.   {
  880.     /*if (TN = ARTL_FindLockTN_ViaLock((struct List *) &AN->an_TrackerList,
  881.               PMsg->pmsg_Lock))
  882.       TN->tn_OpenCnt += 1;
  883.     else*/
  884.     
  885.     if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  886.       ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList, ADDMODE_APPEND);
  887.  
  888.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  889.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName);
  890.   } 
  891.   else if (AN = ARTL_CreateAN_ViaPMsg(PMsg))
  892.     ARTL_AddANToAL(AN, AL);
  893.  
  894.   ARTL_UnlockAL(AL);
  895.   return AN;
  896. }
  897.  
  898. LPROTO void ARTL_PullLockAN( struct AppList *AL, struct PatchMsg *PMsg )
  899. {
  900.   /*********************************************************************
  901.    *
  902.    * ARTL_PullLockAN()
  903.    *
  904.    *********************************************************************
  905.    *
  906.    */
  907.  
  908.   register struct AppNode *AN;
  909.   register struct TrackerNode *TN;
  910.  
  911.   ARTL_LockAL(AL);
  912.  
  913.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  914.   {
  915.     if (TN = ARTL_FindLockTN_ViaLock(
  916.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_Lock))
  917.     {     
  918.       /*TN->tn_OpenCnt -= 1;  
  919.       if (TN->tn_OpenCnt <= 0)*/
  920.  
  921.       {
  922.         if (cfg_TrackUnusedResources)
  923.         {
  924.           TN->tn_InUse = FALSE;
  925.  
  926.           if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  927.           {
  928.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  929.           }
  930.         }
  931.         else /* Kill off the TrackerNode */
  932.         {
  933.           ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  934.  
  935.           if (ARTL_CountTL(&AN->an_TrackerList, PMSGID_ALL) == 0)
  936.           {
  937.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  938.           }
  939.         }       
  940.       }
  941.     }
  942.   }
  943.   ARTL_UnlockAL(AL);
  944. }
  945.  
  946. LPROTO struct AppNode *ARTL_PushFileHandleAN( struct AppList *AL,
  947.  struct PatchMsg *PMsg )
  948. {
  949.   /*********************************************************************
  950.    *
  951.    * ARTL_PushFileHandleAN()
  952.    *
  953.    *********************************************************************
  954.    *
  955.    */
  956.  
  957.   register struct AppNode *AN;
  958.   register struct TrackerNode *TN;
  959.  
  960.   if (!PMsg->pmsg_FH) return NULL;
  961.  
  962.   ARTL_LockAL(AL);
  963.  
  964.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  965.   {           
  966.     if (PMsg->pmsg_ID == PMSGID_OPENFROMLOCK)
  967.     {
  968.       /* Since OpenFromLock() will reqlinquish the lock, we need to
  969.          locate the TrackerNode that repesents that lock and kill
  970.          it. We also determine what pmsg_FHMode is here too. */
  971.       
  972.       if (TN = ARTL_FindLockTN_ViaLock(
  973.             (struct List *) &AN->an_TrackerList, PMsg->pmsg_Lock))
  974.       {
  975.         if (TN->tn_LockMode == SHARED_LOCK)
  976.           PMsg->pmsg_FHMode = MODE_OLDFILE;
  977.         else if (TN->tn_LockMode == EXCLUSIVE_LOCK)
  978.           PMsg->pmsg_FHMode = MODE_NEWFILE;
  979.  
  980.         if (TN->tn_CurDirName && !PMsg->pmsg_CurDirName)
  981.         {
  982.           if (!(PMsg->pmsg_CurDirName =
  983.                    PATCH_StrToVec(PMsg->pmsg_CurDirName)))
  984.           {
  985.             /* Note: Quick & dirty exit */ ARTL_UnlockAL(AL); return NULL;
  986.           }
  987.         }     
  988.         ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  989.       }
  990.     }
  991.  
  992.     /*if (TN = ARTL_FindFileHandleTN_ViaFH(
  993.       (struct List *) &AN->an_TrackerList, PMsg->pmsg_FH))
  994.       TN->tn_OpenCnt += 1;
  995.     else*/ if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  996.       ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList, ADDMODE_APPEND);
  997.  
  998.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  999.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName);    
  1000.   } 
  1001.   else if (AN = ARTL_CreateAN_ViaPMsg(PMsg))
  1002.     ARTL_AddANToAL(AN, AL);
  1003.  
  1004.   ARTL_UnlockAL(AL);
  1005.  
  1006.   return AN;
  1007. }
  1008.  
  1009. LPROTO void ARTL_PullFileHandleAN( struct AppList *AL,
  1010.   struct PatchMsg *PMsg )
  1011. {
  1012.   /*********************************************************************
  1013.    *
  1014.    * ARTL_PullFileHandleAN()
  1015.    *
  1016.    *********************************************************************
  1017.    *
  1018.    */
  1019.  
  1020.   register struct AppNode *AN;
  1021.   register struct TrackerNode *TN;
  1022.  
  1023.   ARTL_LockAL(AL);
  1024.  
  1025.   if (AN = ARTL_FindAN_ViaTaskPtr(AL, PMsg->pmsg_TaskPtr))
  1026.   {
  1027.     if (TN = ARTL_FindFileHandleTN_ViaFH(
  1028.               (struct List *) &AN->an_TrackerList, PMsg->pmsg_FH))
  1029.     {     
  1030.       /*TN->tn_OpenCnt -= 1;
  1031.       
  1032.       if (TN->tn_OpenCnt <= 0)*/
  1033.       {
  1034.         if (cfg_TrackUnusedResources)
  1035.         {
  1036.           TN->tn_InUse = FALSE;
  1037.  
  1038.           if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  1039.           {
  1040.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  1041.           }
  1042.         }
  1043.         else /* Kill off the TrackerNode */
  1044.         {
  1045.           ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  1046.  
  1047.           if (ARTL_CountTL(&AN->an_TrackerList, PMSGID_ALL) == 0)
  1048.           {
  1049.             ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  1050.           }
  1051.         }
  1052.       }
  1053.     }
  1054.   } 
  1055.   ARTL_UnlockAL(AL);
  1056. }
  1057.  
  1058. /**** AppNode **************************************************************/
  1059.  
  1060. LPROTO struct AppList *ARTL_AllocAL( void )
  1061. {
  1062.   /*********************************************************************
  1063.    *
  1064.    * ARTL_AllocAL()
  1065.    *
  1066.    * Allocate an initialize an AppList structure.
  1067.    *
  1068.    *********************************************************************
  1069.    *
  1070.    */
  1071.  
  1072.   register struct AppList *AL;
  1073.   
  1074.   if (AL = MEM_AllocVec(AppList_SIZE))
  1075.   {
  1076.     NewList((struct List *) &AL->al_List);    
  1077.     InitSemaphore((struct SignalSemaphore *) &AL->al_Key);
  1078.   } 
  1079.   return AL;
  1080. }
  1081.  
  1082. LPROTO void ARTL_FreeAL( struct AppList *AL )
  1083. {
  1084.   /*********************************************************************
  1085.    *
  1086.    * ARTL_FreeAL()
  1087.    *
  1088.    * Free an AppList structure and it's associated allocations. Only
  1089.    * pass pointers created with ARTL_AllocAL().
  1090.    *
  1091.    *********************************************************************
  1092.    *
  1093.    */
  1094.  
  1095.   if (AL)
  1096.   { 
  1097.     ARTL_FlushAL(AL); MEM_FreeVec(AL);
  1098.   }
  1099. }
  1100.  
  1101. LPROTO void ARTL_LockAL( struct AppList *AL )
  1102. {
  1103.   /*********************************************************************
  1104.    *
  1105.    * ARTL_LockAL()
  1106.    *
  1107.    * Gain exclusive access to an AppList structure and it's AppNodes /
  1108.    * TrackerNodes.
  1109.    *
  1110.    *********************************************************************
  1111.    *
  1112.    */
  1113.  
  1114.   if (!AL) return;
  1115.  
  1116.   ObtainSemaphore((struct SignalSemaphore *) &AL->al_Key);
  1117. }
  1118.  
  1119. LPROTO void ARTL_UnlockAL( struct AppList *AL )
  1120. {
  1121.   /*********************************************************************
  1122.    *
  1123.    * ARTL_UnlockAL()
  1124.    *
  1125.    * Release the exclusive access obtained via ARTL_LockAL(), so other
  1126.    * tasks can access the AppList.
  1127.    *
  1128.    *********************************************************************
  1129.    *
  1130.    */
  1131.  
  1132.   if (!AL) return;
  1133.  
  1134.   ReleaseSemaphore((struct SignalSemaphore *) &AL->al_Key);
  1135. }
  1136.  
  1137. LPROTO void ARTL_FlushAL( struct AppList *AL )
  1138. {
  1139.   /*********************************************************************
  1140.    *
  1141.    * ARTL_FlushAL()
  1142.    *
  1143.    * Free all AppNodes in an AppList, but keep the AppList itself
  1144.    * intact and valid.
  1145.    *
  1146.    *********************************************************************
  1147.    *
  1148.    */
  1149.  
  1150.   register struct AppNode *AN, *TmpAN;
  1151.  
  1152.   if (!AL) return;
  1153.  
  1154.   ARTL_LockAL(AL);
  1155.   
  1156.   for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1157.        AN->an_Node.ln_Succ;)
  1158.   {
  1159.     TmpAN = (struct AppNode *) AN->an_Node.ln_Succ;
  1160.     ARTL_FreeAN(AN); AN = TmpAN;
  1161.   }
  1162.  
  1163.   NewList((struct List *) &AL->al_List);  
  1164.  
  1165.   ARTL_UnlockAL(AL);
  1166. }
  1167.  
  1168. LPROTO struct AppNode *ARTL_CreateAN_ViaPMsg( struct PatchMsg *PMsg )
  1169. {
  1170.   /*********************************************************************
  1171.    *
  1172.    * ARTL_CreateAN_ViaPMsg()
  1173.    *
  1174.    * Create a fresh AppNode using a PatchMsg.
  1175.    * 
  1176.    *********************************************************************
  1177.    *
  1178.    */
  1179.  
  1180.   register struct AppNode *AN;
  1181.  
  1182.   if (AN = ARTL_AllocAN())
  1183.   {
  1184.     AN->an_TaskPtr = PMsg->pmsg_TaskPtr;
  1185.     AN->an_TaskType = PMsg->pmsg_TaskType;
  1186.     AN->an_LaunchType = PMsg->pmsg_LaunchType;
  1187.     AN->an_SegList = PMsg->pmsg_SegList;
  1188.     ARTL_SetANTaskName(AN, PMsg->pmsg_TaskName);
  1189.     ARTL_SetANCmdName(AN, PMsg->pmsg_CmdName); /* Note: OK to fail */
  1190.  
  1191.     if (AN->an_TaskName) /* Check the result of ARTL_SetTNTaskName() */
  1192.     {
  1193.       register struct TrackerNode *TN;
  1194.  
  1195.       if (TN = ARTL_CreateTN_ViaPMsg(PMsg))
  1196.       {
  1197.         ARTL_AddTNToTL(TN, (struct List *) &AN->an_TrackerList,
  1198.           ADDMODE_APPEND);
  1199.       }
  1200.       else
  1201.       {
  1202.         ARTL_FreeAN(AN); AN = NULL;
  1203.       }
  1204.     }
  1205.     else
  1206.     {
  1207.       ARTL_FreeAN(AN); AN = NULL;
  1208.     }
  1209.   }
  1210.   return AN;
  1211. }
  1212.  
  1213. LPROTO BOOL ARTL_AddANToAL( struct AppNode *InsAN, struct AppList *AL )
  1214. {
  1215.   /*********************************************************************
  1216.    *
  1217.    * ARTL_AddANToAL()
  1218.    *
  1219.    * Append an AppNode to an AppList.
  1220.    *
  1221.    *********************************************************************
  1222.    *
  1223.    */
  1224.  
  1225.   if (!InsAN || !AL) return FALSE;
  1226.   ARTL_LockAL(AL);
  1227.   AddTail((struct List *) &AL->al_List, (struct Node *) InsAN);
  1228.   ARTL_UnlockAL(AL);
  1229.   return TRUE;
  1230. }
  1231.  
  1232. LPROTO struct AppNode *ARTL_AllocAN( void )
  1233. {
  1234.   /*********************************************************************
  1235.    *
  1236.    * ARTL_AllocAN()
  1237.    *
  1238.    * Allocate an initialize an AppNode.
  1239.    *
  1240.    *********************************************************************
  1241.    *
  1242.    */
  1243.  
  1244.   register struct AppNode *AN;
  1245.  
  1246.   if (AN = MEM_AllocVec(AppNode_SIZE))
  1247.   {
  1248.     AN->an_Status = AN_STATUS_ALIVE;
  1249.     NewList((struct List *) &AN->an_TrackerList);
  1250.     DateStamp((struct DateStamp *) &AN->an_TrackDate);
  1251.   }
  1252.   return AN;  
  1253. }
  1254.  
  1255. LPROTO void ARTL_FreeAN( struct AppNode *AN )
  1256. {
  1257.   /*********************************************************************
  1258.    *
  1259.    * ARTL_FreeAN()
  1260.    *
  1261.    * Free an AppNode and it's associated resources. Only pass pointers
  1262.    * created with ARTL_AllocAN() or ARTL_CloneAN().
  1263.    *
  1264.    *********************************************************************
  1265.    *
  1266.    */
  1267.  
  1268.   if (AN)
  1269.   {
  1270.     ARTL_FreeTL((struct List *) &AN->an_TrackerList);
  1271.  
  1272.     if (AN->an_CmdName) MEM_FreeVec(AN->an_CmdName);
  1273.     if (AN->an_TaskName) MEM_FreeVec(AN->an_TaskName);
  1274.  
  1275.     MEM_FreeVec(AN);
  1276.   }
  1277. }
  1278.  
  1279. LPROTO struct AppNode *ARTL_CloneAN( struct AppNode *AN )
  1280. {
  1281.   /*********************************************************************
  1282.    *
  1283.    * ARTL_CloneAN()
  1284.    *
  1285.    * Clone an AppNode structure and it's entire TrackerNode list.
  1286.    *
  1287.    *********************************************************************
  1288.    *
  1289.    */
  1290.  
  1291.   register struct AppNode *NewAN;
  1292.   
  1293.   if (NewAN = MEM_AllocVec(AppNode_SIZE))
  1294.   {
  1295.     NewAN->an_Status = AN->an_Status;
  1296.     NewAN->an_TaskPtr = AN->an_TaskPtr;
  1297.     ARTL_SetANTaskName(NewAN, AN->an_TaskName);
  1298.     ARTL_SetANCmdName(NewAN, AN->an_CmdName); /* Note: OK to fail */
  1299.     NewAN->an_TrackDate.ds_Minute = AN->an_TrackDate.ds_Minute;
  1300.     NewAN->an_TrackDate.ds_Days = AN->an_TrackDate.ds_Days;
  1301.     NewAN->an_TrackDate.ds_Tick = AN->an_TrackDate.ds_Tick;
  1302.     NewAN->an_TaskType = AN->an_TaskType;
  1303.     NewAN->an_LaunchType = AN->an_LaunchType;
  1304.     NewAN->an_SegList = AN->an_SegList;
  1305.  
  1306.     /* Note: AN->an_CmdName may be NULL for tasks. */
  1307.  
  1308.     if (NewAN->an_TaskName) /* Check result of ARTL_SetTNTaskName() */
  1309.     {
  1310.       /* Here we clone the entire TrackerList */
  1311.  
  1312.       register struct TrackerNode *TN;
  1313.       
  1314.       NewList((struct List *) &NewAN->an_TrackerList);
  1315.  
  1316.       for (TN = (struct TrackerNode *) AN->an_TrackerList.lh_Head;
  1317.            TN->tn_Node.ln_Succ ;
  1318.            TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1319.       {
  1320.         register struct TrackerNode *NewTN;
  1321.  
  1322.         if (NewTN = ARTL_CloneTN(TN))
  1323.         {
  1324.           ARTL_AddTNToTL(NewTN, (struct List *) &NewAN->an_TrackerList,
  1325.             ADDMODE_ALPHABETICALLY);
  1326.         }
  1327.         else
  1328.         {
  1329.           /* We've failed to construct the linked list. Abort the loop.
  1330.              ARTL_FreeAN() will clean up the mess for us. */
  1331.  
  1332.           ARTL_FreeAN(NewAN); NewAN = NULL; break;
  1333.         }
  1334.       } /* for(;;) */
  1335.     }
  1336.     else
  1337.     {     
  1338.       ARTL_FreeAN(NewAN); NewAN = NULL;
  1339.     }
  1340.   }
  1341.   return NewAN;
  1342. }
  1343.  
  1344. LPROTO struct AppNode *ARTL_FindAN_ViaTaskPtr( struct AppList *AL,
  1345.   struct Task *TaskPtrToFnd )
  1346. {   
  1347.   /*********************************************************************
  1348.    *
  1349.    * ARTL_FindAN_ViaTaskPtr()
  1350.    *
  1351.    * Find an AppNode in an AppList, using the TaskPtr field.
  1352.    *
  1353.    *********************************************************************
  1354.    *
  1355.    */
  1356.  
  1357.   register struct AppNode *AN;
  1358.  
  1359.   ARTL_LockAL(AL);
  1360.   for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1361.        AN->an_Node.ln_Succ;
  1362.        AN = (struct AppNode *) AN->an_Node.ln_Succ)
  1363.   {
  1364.     if (TaskPtrToFnd == AN->an_TaskPtr)
  1365.     {
  1366.       ARTL_UnlockAL(AL); return AN;
  1367.     }
  1368.   }
  1369.   ARTL_UnlockAL(AL);
  1370.  
  1371.   return NULL;
  1372. }
  1373.  
  1374. LPROTO void ARTL_UnlinkAN( struct AppNode *AN )
  1375. {
  1376.   /*********************************************************************
  1377.    *
  1378.    * ARTL_UnlinkAN()
  1379.    *
  1380.    * Unlink an AppNode from an AppList. Usually this is called before
  1381.    * deallocation of the AppNode itself.
  1382.    * 
  1383.    *********************************************************************
  1384.    *
  1385.    */
  1386.  
  1387.   if ((AN->an_Node.ln_Succ == NULL) || (AN->an_Node.ln_Pred == NULL))
  1388.     return;
  1389.   Remove((struct Node *) AN);
  1390.   AN->an_Node.ln_Succ = NULL;
  1391.   AN->an_Node.ln_Pred = NULL;
  1392. }
  1393.  
  1394. LPROTO UWORD ARTL_UpdateANStatus( struct AppNode *AN )
  1395. {
  1396.   /*********************************************************************
  1397.    *
  1398.    * ARTL_UpdateANStatus()
  1399.    *
  1400.    * Update the status field (an_Status) of an AppNode structure. The
  1401.    * contents of an_Status is returned by this routine also.
  1402.    * 
  1403.    * Notes
  1404.    * -----
  1405.    *
  1406.    * This routine will give incorrect results if the task/process
  1407.    * modifies it's own name (i.e. Task->tc_Node.ln_Name) after
  1408.    * SysTracker created an AppNode for that task/process. This would
  1409.    * cause SysTracker to report the program as dead when in fact it's
  1410.    * really alive.
  1411.    *  
  1412.    * Notes on CLI & Shells
  1413.    * ---------------------
  1414.    *
  1415.    * Checking for the existances of a TaskPtr is fine for programs
  1416.    * launched from WB, but it doesn't really work for programs started
  1417.    * from CLI/Shell since they share the same TaskPtr as the CLI/Shell
  1418.    * process itself. I've added a work around that will check the
  1419.    * Process->pr_CLI->cli_Module to see if the command is still loaded.
  1420.    *
  1421.    *
  1422.    *********************************************************************
  1423.    *
  1424.    */
  1425.  
  1426.   register struct Process *ProcessPtr;
  1427.  
  1428.   Forbid();
  1429.  
  1430.   if (cfg_BeSystemLegal)
  1431.   {
  1432.     ProcessPtr = (struct Process *) FindTask(AN->an_TaskName);
  1433.   }
  1434.   else
  1435.   {
  1436.     if (R_IsTaskPtrValid(AN->an_TaskPtr))
  1437.     {
  1438.       ProcessPtr = (struct Process *) AN->an_TaskPtr;
  1439.     }
  1440.     else
  1441.     {
  1442.       ProcessPtr = NULL;
  1443.     }
  1444.   }
  1445.  
  1446.   if (ProcessPtr)
  1447.   {
  1448.     AN->an_Status = AN_STATUS_ALIVE;
  1449.  
  1450.     /* If it's CLI based, we must do a few more checks... */
  1451.  
  1452.     if (AN->an_LaunchType == LT_CLI)
  1453.     {   
  1454.       if (ProcessPtr &&
  1455.           (ProcessPtr->pr_Task.tc_Node.ln_Type == NT_PROCESS))
  1456.       {   
  1457.         register struct CommandLineInterface *CLI = NULL;
  1458.  
  1459.         AN->an_Status = AN_STATUS_ALIVE; /* Default */
  1460.         CLI = BADDR(ProcessPtr->pr_CLI);    
  1461.         if (AN->an_CmdName && CLI)
  1462.         {
  1463.           if (CLI->cli_Module)
  1464.           {
  1465.             /* Command is still loaded into CLI. */
  1466.         
  1467.             AN->an_Status = AN_STATUS_ALIVE;
  1468.           }
  1469.           else
  1470.           {
  1471.             /* Command has been unloaded from CLI (or it's detached
  1472.                itself from the CLI). */
  1473.         
  1474.             AN->an_Status = AN_STATUS_DEAD;
  1475.           }
  1476.         }
  1477.       }
  1478.     }
  1479.   }
  1480.   else
  1481.   {
  1482.     /* OK, we can't find the task. This means it's been removed
  1483.        or the task has changed it's tc_Node.ln_Name field. Either
  1484.        way, SysTracker considers it dead. */
  1485.     
  1486.     AN->an_Status = AN_STATUS_DEAD;
  1487.   }
  1488.  
  1489.   Permit();
  1490.  
  1491.   return AN->an_Status;
  1492. }
  1493.  
  1494. LPROTO UBYTE *ARTL_SetANTaskName( struct AppNode *AN, UBYTE *TaskName )
  1495. {
  1496.   /*********************************************************************
  1497.    *
  1498.    * ARTL_SetANTaskName()
  1499.    *
  1500.    * Set the AppNode->an_TaskName field of an AppNode structure.
  1501.    *
  1502.    *********************************************************************
  1503.    *
  1504.    */
  1505.  
  1506.   register UBYTE *FinalTaskName = NULL;
  1507.  
  1508.   if (!AN) return FALSE;
  1509.   
  1510.   if (AN->an_TaskName)
  1511.   {
  1512.     MEM_FreeVec(AN->an_TaskName); AN->an_TaskName = NULL;
  1513.   }
  1514.  
  1515.   if (!TaskName)
  1516.     FinalTaskName = MEM_StrToVec(STR_Get(SID_UNNAMED_BRACKET));
  1517.   else if (!TaskName[0])
  1518.     FinalTaskName = MEM_StrToVec(STR_Get(SID_EMPTY_NAME_BRACKET));
  1519.   else
  1520.     FinalTaskName = MEM_StrToVec(TaskName);
  1521.   
  1522.   AN->an_TaskName = FinalTaskName;
  1523.   return FinalTaskName;
  1524. }
  1525.  
  1526. LPROTO UBYTE *ARTL_SetANCmdName( struct AppNode *AN, UBYTE *CmdName )
  1527. {
  1528.   /*********************************************************************
  1529.    *
  1530.    * ARTL_SetANCmdName()
  1531.    * 
  1532.    * Set the AN->an_CmdName field of an AppNode structure.
  1533.    *
  1534.    *********************************************************************
  1535.    *
  1536.    */
  1537.  
  1538.   register UBYTE *FinalCmdName = NULL;
  1539.  
  1540.   if (!AN) return FALSE;
  1541.   
  1542.   if (AN->an_CmdName)
  1543.   {
  1544.     MEM_FreeVec(AN->an_CmdName); AN->an_CmdName = NULL;
  1545.   }
  1546.  
  1547.   /* If we can't get a decent process name, then leave the pointer
  1548.      NULL. This means the task name will be displayed/used instead. */
  1549.   
  1550.   if (!CmdName) FinalCmdName = NULL;
  1551.   else if (!CmdName[0]) FinalCmdName = NULL;
  1552.   else FinalCmdName = MEM_StrToVec(CmdName);
  1553.   
  1554.   AN->an_CmdName = FinalCmdName;
  1555.  
  1556.   return FinalCmdName;
  1557. }
  1558.  
  1559. LPROTO void ARTL_UpdateAL( struct AppList *AL )
  1560. {
  1561.   /*********************************************************************
  1562.    *
  1563.    * ARTL_UpdateAL()
  1564.    *
  1565.    * Refresh the Application GUI lister to reflect the current state
  1566.    * of the main AppList (ARTL).
  1567.    *
  1568.    *********************************************************************
  1569.    *
  1570.    */
  1571.  
  1572.   register struct AppNode *AN;
  1573.  
  1574.   GUI_Act_List_Clear(OID_MAIN_APPLIST);
  1575.   GUI_Act_List_Clear(OID_MAIN_TRACKERLIST);
  1576.  
  1577.   GUI_Set_List_Quiet(OID_MAIN_APPLIST, TRUE);
  1578.   ARTL_LockAL(AL);
  1579.  
  1580.   for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1581.        AN->an_Node.ln_Succ;
  1582.        AN = (struct AppNode *) AN->an_Node.ln_Succ)
  1583.   {
  1584.     ARTL_UpdateANStatus(AN);
  1585.  
  1586.     if (cfg_ShowUnusedResources)
  1587.       GUI_Act_List_InsertABC(OID_MAIN_APPLIST, AN);
  1588.     else
  1589.       GUI_Act_List_InsertABC(OID_MAIN_APPLIST, AN);
  1590.   }
  1591.   ARTL_UnlockAL(AL);
  1592.   GUI_Set_List_Quiet(OID_MAIN_APPLIST, FALSE);
  1593. }
  1594.  
  1595. LPROTO BOOL ARTL_SaveALAsASCII( struct AppList *AL, UBYTE *DestFile,
  1596.   BOOL SaveAll )
  1597. {
  1598.   /*********************************************************************
  1599.    *
  1600.    * ARTL_SaveALAsASCII()
  1601.    *
  1602.    * Create and save a readable ASCII file of the main AppList (ARTL).
  1603.    *
  1604.    *********************************************************************
  1605.    *
  1606.    */
  1607.  
  1608.   register struct AppNode *AN;
  1609.   register BPTR OutFH;
  1610.   
  1611.   OutFH = Open(DestFile, MODE_NEWFILE);
  1612.  
  1613.   /* Take advantage of SetVBuf() if we're running under DOS v40.
  1614.  
  1615.      Note: v39 of DOS doesn't have the SetVBuf() code enabled so
  1616.            there's no point in checking for v39 too. */
  1617.  
  1618.   if (OutFH && (DOSBase->dl_lib.lib_Version >= 40))
  1619.   {
  1620.     if (SetVBuf(OutFH, NULL, BUF_FULL, IO_BUFFER_SIZE) != 0)
  1621.     {
  1622.       Close(OutFH); OutFH = 0;
  1623.     }   
  1624.   }
  1625.  
  1626.   if (OutFH)
  1627.   {
  1628.     struct DateStamp DS;
  1629.     UBYTE DateStrBuf[130];
  1630.     DateStamp((struct DateStamp *) &DS);
  1631.     
  1632.     if (R_DateStampToStr((struct DateStamp *) &DS,
  1633.           (UBYTE *) &DateStrBuf ))
  1634.     {
  1635.       register UBYTE *LineBuf = MEM_AllocVec(TEMP_BUFFER_SIZE);
  1636.  
  1637.       if (LineBuf)
  1638.       {
  1639.         FPrintf(OutFH, STR_Get(SID_GENERATED_WITH), VERS, &DateStrBuf);
  1640.  
  1641.         ARTL_LockAL(AL);
  1642.  
  1643.         for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1644.              AN->an_Node.ln_Succ;
  1645.              AN = (struct AppNode *) AN->an_Node.ln_Succ)
  1646.         {         
  1647.           if (AN->an_Status == AN_STATUS_ALIVE)
  1648.           {         
  1649.             /* Note: When an AppNode is cloned, the TrackerNodes
  1650.                      are sorted alphabetically. */
  1651.  
  1652.             struct AppNode *ANClone = ARTL_CloneAN(AN);
  1653.  
  1654.             if (ANClone)
  1655.             {
  1656.               register ULONG LineLen = 0;
  1657.               register UBYTE *LinePtr = NULL;
  1658.  
  1659.               sprintf(LineBuf, STR_Get(SID_IS_USING),
  1660.                 AN->an_CmdName ? AN->an_CmdName : AN->an_TaskName);
  1661.               FPrintf(OutFH, LineBuf);
  1662.               LinePtr = LineBuf; LineLen = strlen(LineBuf) - 1;
  1663.               while (LineLen--) *LinePtr++ = '=';
  1664.               *LinePtr++ = '\n'; *LinePtr = 0;
  1665.               FPrintf(OutFH, LineBuf);
  1666.  
  1667.               /***********************************************************/
  1668.  
  1669.               ARTL_SaveAL_Libs(ANClone, OutFH, SaveAll);
  1670.               ARTL_SaveAL_Devs(ANClone, OutFH, SaveAll);
  1671.               ARTL_SaveAL_Fonts(ANClone, OutFH, SaveAll);
  1672.               ARTL_SaveAL_Locks(ANClone, OutFH, SaveAll);
  1673.               ARTL_SaveAL_FHs(ANClone, OutFH, SaveAll);
  1674.  
  1675.               /***********************************************************/
  1676.  
  1677.               FPrintf(OutFH, "\n");
  1678.  
  1679.               ARTL_FreeAN(ANClone); ANClone = NULL;
  1680.             }
  1681.           }
  1682.         } /* for(;;) */
  1683.         FPrintf(OutFH,
  1684. "*** SysTracker is Copyright © " YEAR " Andrew Bell. All rights reserved. ***\n"
  1685. "\n");
  1686.  
  1687.         ARTL_UnlockAL(AL);
  1688.         MEM_FreeVec(LineBuf);
  1689.       }
  1690.     }
  1691.     Close(OutFH);
  1692.   }
  1693.   return TRUE;
  1694. }
  1695.  
  1696. LPROTO BOOL ARTL_SaveAL_Libs( struct AppNode *ANClone, BPTR OutFH,
  1697.   BOOL SaveAll )
  1698. {
  1699.   register struct TrackerNode *TN;
  1700.   register ULONG AmtSaved = 0;
  1701.   register LONG HeaderPOF;
  1702.   
  1703.   HeaderPOF = Seek(OutFH, 0, OFFSET_CURRENT);
  1704.   if (HeaderPOF == -1) return FALSE;
  1705.   
  1706.   FPrintf(OutFH, "\n"
  1707.                  "    Libraries\n"
  1708.                  "    =========\n");                 
  1709.   for (TN = (struct TrackerNode *) ANClone->an_TrackerList.lh_Head;
  1710.        TN->tn_Node.ln_Succ;
  1711.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1712.   {
  1713.     if (SaveAll || (!SaveAll && TN->tn_InUse))
  1714.     {
  1715.       if (TN->tn_ID == PMSGID_OPENLIBRARY)
  1716.       {
  1717.         FPrintf(OutFH, "    `%s'\n",
  1718.          (!TN->tn_LibName || !strlen(TN->tn_LibName)) ?
  1719.           "(unnamed library)" : TN->tn_LibName);
  1720.         AmtSaved++;
  1721.       }
  1722.     }
  1723.   }
  1724.  
  1725.   if (AmtSaved == 0)
  1726.     if (Seek(OutFH, HeaderPOF, OFFSET_BEGINNING) == -1)
  1727.       return FALSE;
  1728.  
  1729.   return TRUE;
  1730. }
  1731.  
  1732. LPROTO BOOL ARTL_SaveAL_Devs( struct AppNode *ANClone, BPTR OutFH,
  1733.   BOOL SaveAll )
  1734. {
  1735.   register struct TrackerNode *TN;
  1736.   register ULONG AmtSaved = 0;
  1737.   register LONG HeaderPOF;
  1738.   
  1739.   HeaderPOF = Seek(OutFH, 0, OFFSET_CURRENT);
  1740.   if (HeaderPOF == -1) return FALSE;
  1741.  
  1742.   FPrintf(OutFH, "\n"
  1743.                  "    Devices\n"
  1744.                  "    =======\n");
  1745.  
  1746.   for (TN = (struct TrackerNode *) ANClone->an_TrackerList.lh_Head;
  1747.        TN->tn_Node.ln_Succ;
  1748.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1749.   {
  1750.     if (SaveAll || (!SaveAll && TN->tn_InUse))
  1751.     {
  1752.       if (TN->tn_ID == PMSGID_OPENDEVICE)
  1753.       {
  1754.         FPrintf(OutFH, "    `%s'\n",
  1755.           (!TN->tn_DevName || !strlen(TN->tn_DevName)) ?
  1756.           "(unnamed device)" : TN->tn_DevName);
  1757.  
  1758.         AmtSaved++;
  1759.       }
  1760.     }
  1761.   }
  1762.  
  1763.   if (AmtSaved == 0)
  1764.     if (Seek(OutFH, HeaderPOF, OFFSET_BEGINNING) == -1)
  1765.       return FALSE;
  1766.  
  1767.   return TRUE;
  1768. }
  1769.  
  1770. LPROTO BOOL ARTL_SaveAL_Fonts( struct AppNode *ANClone, BPTR OutFH,
  1771.   BOOL SaveAll )
  1772. {
  1773.   register struct TrackerNode *TN;
  1774.   register ULONG AmtSaved = 0;
  1775.   register LONG HeaderPOF;
  1776.   
  1777.   HeaderPOF = Seek(OutFH, 0, OFFSET_CURRENT);
  1778.   if (HeaderPOF == -1) return FALSE;
  1779.  
  1780.   FPrintf(OutFH, "\n"
  1781.                  "    Fonts\n"
  1782.                  "    =====\n");
  1783.   for (TN = (struct TrackerNode *) ANClone->an_TrackerList.lh_Head;
  1784.        TN->tn_Node.ln_Succ;
  1785.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1786.   {
  1787.     if (SaveAll || (!SaveAll && TN->tn_InUse))
  1788.     {
  1789.       if (TN->tn_ID == PMSGID_OPENFONT)
  1790.       {
  1791.         FPrintf(OutFH, "    `%s'\n",
  1792.            (!TN->tn_FontName || !strlen(TN->tn_FontName)) ?
  1793.               "(unnamed font)" : TN->tn_FontName);
  1794.  
  1795.         AmtSaved++;
  1796.       }
  1797.     }
  1798.   }
  1799.  
  1800.   if (AmtSaved == 0)
  1801.     if (Seek(OutFH, HeaderPOF, OFFSET_BEGINNING) == -1)
  1802.       return FALSE;
  1803.  
  1804.   return TRUE;
  1805. }
  1806.  
  1807. LPROTO BOOL ARTL_SaveAL_Locks( struct AppNode *ANClone, BPTR OutFH,
  1808.   BOOL SaveAll )
  1809. {
  1810.   register struct TrackerNode *TN;
  1811.   register ULONG AmtSaved = 0;
  1812.   register LONG HeaderPOF;
  1813.   
  1814.   HeaderPOF = Seek(OutFH, 0, OFFSET_CURRENT);
  1815.   if (HeaderPOF == -1) return FALSE;
  1816.  
  1817.   FPrintf(OutFH, "\n"
  1818.                  "    Locks\n"
  1819.                  "    =====\n");
  1820.  
  1821.   for (TN = (struct TrackerNode *) ANClone->an_TrackerList.lh_Head;
  1822.        TN->tn_Node.ln_Succ;
  1823.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1824.   {
  1825.     if (TN->tn_ID == PMSGID_LOCK)
  1826.     {
  1827.       if (SaveAll || (!SaveAll && TN->tn_InUse))
  1828.       {
  1829.         FPrintf(OutFH, "    `%s'\n",
  1830.           (!TN->tn_LockName || !strlen(TN->tn_LockName)) ?
  1831.            "(unnamed lock)" : TN->tn_LockName);
  1832.  
  1833.         AmtSaved++;
  1834.       }
  1835.     }
  1836.   }
  1837.  
  1838.   if (AmtSaved == 0)
  1839.     if (Seek(OutFH, HeaderPOF, OFFSET_BEGINNING) == -1)
  1840.       return FALSE;
  1841.  
  1842.   return TRUE;
  1843. }
  1844.  
  1845. LPROTO BOOL ARTL_SaveAL_FHs( struct AppNode *ANClone, BPTR OutFH,
  1846.   BOOL SaveAll )
  1847. {
  1848.   register struct TrackerNode *TN;
  1849.   register ULONG AmtSaved = 0;
  1850.   register LONG HeaderPOF;
  1851.   
  1852.   HeaderPOF = Seek(OutFH, 0, OFFSET_CURRENT);
  1853.   if (HeaderPOF == -1) return FALSE;
  1854.  
  1855.   FPrintf(OutFH, "\n"
  1856.                  "    Files accessed\n"
  1857.                  "    ==============\n");
  1858.  
  1859.   for (TN = (struct TrackerNode *) ANClone->an_TrackerList.lh_Head;
  1860.        TN->tn_Node.ln_Succ;
  1861.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  1862.   {
  1863.     if (SaveAll || (!SaveAll && TN->tn_InUse))
  1864.     {
  1865.       if ((TN->tn_ID == PMSGID_OPEN) ||
  1866.           (TN->tn_ID == PMSGID_OPENFROMLOCK))
  1867.       {
  1868.         FPrintf(OutFH, "    `%s'\n",
  1869.           (!TN->tn_FHName || !strlen(TN->tn_FHName)) ?
  1870.           "(unnamed file)" : TN->tn_FHName);
  1871.  
  1872.         AmtSaved++;
  1873.       }
  1874.     }
  1875.   }
  1876.  
  1877.   if (AmtSaved == 0)
  1878.     if (Seek(OutFH, HeaderPOF, OFFSET_BEGINNING) == -1)
  1879.       return FALSE;
  1880.  
  1881.   return TRUE;
  1882. }
  1883.  
  1884. LPROTO LONG ARTL_GetANListIndex_ViaTaskPtr( struct Task *TaskPtr )
  1885. {
  1886.   /*********************************************************************
  1887.    *
  1888.    * ARTL_GetANListIndex_ViaTaskPtr()
  1889.    * 
  1890.    * Find an AppNode in the main GUI lister via a TaskPtr. Remember
  1891.    * that the GUI list uses cloned AppNodes!
  1892.    *
  1893.    *********************************************************************
  1894.    *
  1895.    */
  1896.  
  1897.   register LONG Index = 0;
  1898.  
  1899.   for (Index = 0 ;; Index++)
  1900.   {
  1901.     struct AppNode *AN = GUI_Get_List_Entry(OID_MAIN_APPLIST, Index);
  1902.     if (!AN) break;
  1903.     if (TaskPtr == AN->an_TaskPtr) return Index;
  1904.   }
  1905.   return -1;
  1906. }
  1907.  
  1908. GPROTO LONG ARTL_ClearDeadANs( struct AppList *AL )
  1909. {
  1910.   /*********************************************************************
  1911.    *
  1912.    * ARTL_ClearDeadANs()
  1913.    * 
  1914.    * Delete those AppNodes in an AppList that no longer have a task
  1915.    * associated with it.
  1916.    *
  1917.    *********************************************************************
  1918.    *
  1919.    */
  1920.  
  1921.   register LONG DeadANCnt = 0;
  1922.   register struct AppNode *AN, *NextAN;
  1923.  
  1924.   ARTL_LockAL(AL);
  1925.  
  1926.   for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1927.        AN->an_Node.ln_Succ;)
  1928.   {
  1929.     NextAN = (struct AppNode *) AN->an_Node.ln_Succ;
  1930.  
  1931.     if (ARTL_UpdateANStatus(AN) == AN_STATUS_DEAD)
  1932.     {
  1933.       ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  1934.       DeadANCnt++;
  1935.     }
  1936.     
  1937.     AN = NextAN;
  1938.   }
  1939.   ARTL_UnlockAL(AL);
  1940.   ARTL_UpdateAL(AL);
  1941.   
  1942.   return DeadANCnt;
  1943. }
  1944.  
  1945. GPROTO ULONG ARTL_ClearUnusedANs( struct AppList *AL )
  1946. {
  1947.   /*********************************************************************
  1948.    *
  1949.    * ARTL_ClearUnusedANs()
  1950.    *
  1951.    * Clear all AppNodes that don't have any allocated resources.
  1952.    *
  1953.    *********************************************************************
  1954.    *
  1955.    */
  1956.  
  1957.   register LONG FreedANCnt = 0;
  1958.   register struct AppNode *AN, *NextAN;
  1959.  
  1960.   ARTL_LockAL(AL);
  1961.  
  1962.   for (AN = (struct AppNode *) AL->al_List.lh_Head;
  1963.        AN->an_Node.ln_Succ;)
  1964.   {
  1965.     NextAN = (struct AppNode *) AN->an_Node.ln_Succ;
  1966.  
  1967.     ARTL_ClearUnusedTNs(&AN->an_TrackerList);
  1968.  
  1969.     if (ARTL_CountTNsInUse(&AN->an_TrackerList) == 0)
  1970.     {
  1971.       ARTL_UnlinkAN(AN); ARTL_FreeAN(AN);
  1972.       FreedANCnt++;
  1973.     }   
  1974.     AN = NextAN;
  1975.   }
  1976.   ARTL_UnlockAL(AL);
  1977.   ARTL_UpdateAL(AL);
  1978.   
  1979.   return FreedANCnt;
  1980. }
  1981.  
  1982. /**** TrackerNode **********************************************************/
  1983.  
  1984. LPROTO struct TrackerNode *ARTL_CreateTN_ViaPMsg( struct PatchMsg *PMsg )
  1985. {
  1986.   /*********************************************************************
  1987.    *
  1988.    * ARTL_CreateTN_ViaPMsg()
  1989.    *
  1990.    * Create a TrackerNode using a PatchMsg.
  1991.    *
  1992.    *********************************************************************
  1993.    *
  1994.    */
  1995.  
  1996.   register struct TrackerNode *TN;
  1997.   register BOOL Success = FALSE;
  1998.  
  1999.   if (TN = ARTL_AllocTN())
  2000.   {
  2001.     UBYTE TmpBuf[256];
  2002.  
  2003.     TN->tn_OpenCnt = 1; /* The creation of this TN implies that something
  2004.                            has opened it. */
  2005.     TN->tn_InUse = TRUE; /* It also implies that something is using it. */
  2006.  
  2007.     switch(PMsg->pmsg_ID)
  2008.     {
  2009.       case PMSGID_OPENLIBRARY:
  2010.         TN->tn_ID = PMSGID_OPENLIBRARY;
  2011.         TN->tn_LibName = MEM_StrToVec(PMsg->pmsg_LibName);
  2012.         TN->tn_LibVer = PMsg->pmsg_LibVer;
  2013.         TN->tn_LibBase = PMsg->pmsg_LibBase;
  2014.         if (TN->tn_LibName) Success = TRUE;
  2015.         break;
  2016.  
  2017.       case PMSGID_OPENDEVICE:
  2018.         TN->tn_ID = PMSGID_OPENDEVICE;
  2019.         TN->tn_DevName = MEM_StrToVec(PMsg->pmsg_DevName);
  2020.         TN->tn_DevUnitNum = PMsg->pmsg_DevUnitNum;
  2021.         TN->tn_DevIOReq = PMsg->pmsg_DevIOReq;
  2022.         TN->tn_DevFlags = PMsg->pmsg_DevFlags;
  2023.         if (TN->tn_DevName) Success = TRUE;
  2024.         break;
  2025.  
  2026.       case PMSGID_OPENFONT:
  2027.         TN->tn_ID = PMSGID_OPENFONT;
  2028.         TN->tn_FontTextAttr = PMsg->pmsg_FontTextAttr;
  2029.         TN->tn_FontTextFont = PMsg->pmsg_FontTextFont;
  2030.         sprintf((UBYTE *)&TmpBuf, "%s/%lu",
  2031.           PMsg->pmsg_FontName, (ULONG) PMsg->pmsg_FontYSize);
  2032.         TN->tn_FontName = MEM_StrToVec((UBYTE *)&TmpBuf);
  2033.         TN->tn_FontYSize = PMsg->pmsg_FontYSize;
  2034.         TN->tn_FontStyle = PMsg->pmsg_FontStyle;
  2035.         TN->tn_FontFlags = PMsg->pmsg_FontFlags;
  2036.         if (TN->tn_FontName) Success = TRUE;
  2037.         break;
  2038.  
  2039.       case PMSGID_LOCK:
  2040.         TN->tn_ID = PMSGID_LOCK;
  2041.         TN->tn_Lock = PMsg->pmsg_Lock;
  2042.         TN->tn_LockMode = PMsg->pmsg_LockMode;
  2043.         TN->tn_LockName = MEM_StrToVec(PMsg->pmsg_LockName);
  2044.         if (TN->tn_LockName) Success = TRUE;
  2045.         break;
  2046.  
  2047.       case PMSGID_OPEN:
  2048.         TN->tn_ID = PMSGID_OPEN;
  2049.         TN->tn_FH = PMsg->pmsg_FH;
  2050.         TN->tn_FHMode = PMsg->pmsg_FHMode;
  2051.         TN->tn_FHName = MEM_StrToVec(PMsg->pmsg_FHName);
  2052.         if (TN->tn_FHName) Success = TRUE;
  2053.         break;
  2054.  
  2055.       case PMSGID_OPENFROMLOCK:
  2056.         TN->tn_ID = PMSGID_OPENFROMLOCK;
  2057.         TN->tn_Lock = PMsg->pmsg_Lock;
  2058.         TN->tn_FH = PMsg->pmsg_FH;
  2059.         TN->tn_FHName = MEM_StrToVec(PMsg->pmsg_FHName);
  2060.         if (TN->tn_FHName) Success = TRUE;
  2061.         break;
  2062.  
  2063.       default: break;
  2064.     }
  2065.  
  2066.     if (!Success)
  2067.     {     
  2068.       ARTL_FreeTN(TN); TN = NULL;
  2069.     }
  2070.     else
  2071.     {
  2072.       /* If this is a file related TrackerNode, build the full path. */
  2073.       
  2074.       if (!ATRL_BuildTNPath(TN))
  2075.       {
  2076.         ARTL_FreeTN(TN); TN = NULL;
  2077.       }
  2078.     }
  2079.   }
  2080.   return TN;
  2081. }
  2082.  
  2083. LPROTO BOOL ARTL_AddTNToTL(
  2084.   struct TrackerNode *InsTN, struct List *TL, ULONG AddMode )
  2085. {
  2086.   /*********************************************************************
  2087.    *
  2088.    * ARTL_AddTNToTL()
  2089.    *
  2090.    * Add a TrackerNode to a TrackerList.
  2091.    *
  2092.    *********************************************************************
  2093.    *
  2094.    */
  2095.  
  2096.   if (!InsTN || !TL) return FALSE;
  2097.  
  2098.   if (AddMode == ADDMODE_ALPHABETICALLY)
  2099.   {
  2100.     register struct TrackerNode *TN;
  2101.  
  2102.     for (TN = (struct TrackerNode *) TL->lh_Head;
  2103.          TN->tn_Node.ln_Succ;
  2104.          TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2105.     {
  2106.       register LONG r;
  2107.       
  2108.       if ((TN->tn_ID == PMSGID_OPENLIBRARY) &&
  2109.           (InsTN->tn_ID == PMSGID_OPENLIBRARY))
  2110.         r = Stricmp(TN->tn_LibName, InsTN->tn_LibName);
  2111.       else if ((TN->tn_ID == PMSGID_OPENDEVICE) &&
  2112.               (InsTN->tn_ID == PMSGID_OPENDEVICE))
  2113.         r = Stricmp(TN->tn_DevName, InsTN->tn_DevName);
  2114.       else if ((TN->tn_ID == PMSGID_OPENFONT) &&
  2115.               (InsTN->tn_ID == PMSGID_OPENFONT))
  2116.         r = Stricmp(TN->tn_FontName, InsTN->tn_FontName);
  2117.       else r = -1;
  2118.  
  2119.       if (r >= 0)
  2120.       {
  2121.         Insert((struct List *) &TL,
  2122.                (struct Node *) InsTN,
  2123.                (struct Node *) TN->tn_Node.ln_Pred);
  2124.  
  2125.         return TRUE;
  2126.       }
  2127.     }
  2128.     AddTail(TL, (struct Node *) InsTN); 
  2129.   }
  2130.   else
  2131.     AddTail(TL, (struct Node *) InsTN);
  2132.  
  2133.   return TRUE;
  2134. }
  2135.  
  2136. LPROTO struct TrackerNode *ARTL_AllocTN( void )
  2137. {
  2138.   /*********************************************************************
  2139.    *
  2140.    * ARTL_AllocTN()
  2141.    *
  2142.    * Allocate and initialize a TrackerNode structure.
  2143.    *
  2144.    *********************************************************************
  2145.    *
  2146.    */
  2147.  
  2148.   register struct TrackerNode *TN;
  2149.  
  2150.   if (TN = MEM_AllocVec(TrackerNode_SIZE))
  2151.   {
  2152.     DateStamp((struct DateStamp *) &TN->tn_TrackDate);
  2153.   } 
  2154.   return TN;
  2155. }
  2156.  
  2157. LPROTO void ARTL_FreeTN( struct TrackerNode *TN )
  2158. {
  2159.   /*********************************************************************
  2160.    *
  2161.    * ARTL_FreeTN()
  2162.    *
  2163.    * Free a TrackerNode structure and it's associated resources. Only
  2164.    * pass pointers from ARTL_AllocTN() or ARTL_CloneTN().
  2165.    *
  2166.    *********************************************************************
  2167.    *
  2168.    */
  2169.  
  2170.   if (TN)
  2171.   {
  2172.     if (TN->tn_LibName) MEM_FreeVec(TN->tn_LibName);
  2173.     if (TN->tn_DevName) MEM_FreeVec(TN->tn_DevName);
  2174.     if (TN->tn_FontName) MEM_FreeVec(TN->tn_FontName);
  2175.     if (TN->tn_FHName) MEM_FreeVec(TN->tn_FHName);
  2176.     if (TN->tn_LockName) MEM_FreeVec(TN->tn_LockName);
  2177.     if (TN->tn_CurDirName) MEM_FreeVec(TN->tn_CurDirName);
  2178.     MEM_FreeVec(TN);
  2179.   }
  2180. }
  2181.  
  2182. LPROTO struct TrackerNode *ARTL_CloneTN( struct TrackerNode *TN )
  2183. {
  2184.   /*********************************************************************
  2185.    *
  2186.    * ARTL_CloneTN()
  2187.    *
  2188.    * Clone a TrackerNode and it's associated resources.
  2189.    *
  2190.    *********************************************************************
  2191.    *
  2192.    */
  2193.  
  2194.   register struct TrackerNode *NewTN;
  2195.   register BOOL Success = FALSE; /* Assume an error will happen */
  2196.  
  2197.   if (NewTN = MEM_AllocVec(TrackerNode_SIZE))
  2198.   {
  2199.     NewTN->tn_ID = TN->tn_ID;
  2200.     NewTN->tn_OpenCnt = TN->tn_OpenCnt;
  2201.     NewTN->tn_InUse = TN->tn_InUse;
  2202.     NewTN->tn_TrackDate.ds_Minute = TN->tn_TrackDate.ds_Minute;
  2203.     NewTN->tn_TrackDate.ds_Days = TN->tn_TrackDate.ds_Days;
  2204.     NewTN->tn_TrackDate.ds_Tick = TN->tn_TrackDate.ds_Tick;
  2205.  
  2206.     switch(NewTN->tn_ID)
  2207.     {
  2208.       case PMSGID_OPENLIBRARY:
  2209.         NewTN->tn_LibName = MEM_StrToVec(TN->tn_LibName);
  2210.         NewTN->tn_LibVer = TN->tn_LibVer;
  2211.         NewTN->tn_LibBase = TN->tn_LibBase;
  2212.         if (NewTN->tn_LibName) Success = TRUE;
  2213.         break;
  2214.  
  2215.       case PMSGID_OPENDEVICE:
  2216.         NewTN->tn_DevName = MEM_StrToVec(TN->tn_DevName); 
  2217.         NewTN->tn_DevUnitNum = TN->tn_DevUnitNum;
  2218.         NewTN->tn_DevIOReq = TN->tn_DevIOReq;
  2219.         NewTN->tn_DevFlags = TN->tn_DevFlags;
  2220.         if (NewTN->tn_DevName) Success = TRUE;
  2221.         break;
  2222.  
  2223.       case PMSGID_OPENFONT:
  2224.         NewTN->tn_ID = TN->tn_ID;
  2225.         NewTN->tn_FontTextAttr = TN->tn_FontTextAttr;
  2226.         NewTN->tn_FontTextFont = TN->tn_FontTextFont;
  2227.         NewTN->tn_FontName = MEM_StrToVec(TN->tn_FontName);
  2228.         NewTN->tn_FontYSize = TN->tn_FontYSize;
  2229.         NewTN->tn_FontStyle = TN->tn_FontStyle;
  2230.         NewTN->tn_FontFlags = TN->tn_FontFlags;
  2231.         if (NewTN->tn_FontName) Success = TRUE;
  2232.         break;
  2233.  
  2234.       case PMSGID_LOCK:
  2235.         NewTN->tn_ID = TN->tn_ID;
  2236.         NewTN->tn_Lock = TN->tn_Lock;
  2237.         NewTN->tn_LockMode = TN->tn_LockMode;
  2238.         NewTN->tn_LockName = MEM_StrToVec(TN->tn_LockName);
  2239.         if (TN->tn_CurDirName)
  2240.           if (!(NewTN->tn_CurDirName = MEM_StrToVec(TN->tn_CurDirName)))
  2241.             break;
  2242.  
  2243.         if (NewTN->tn_LockName) Success = TRUE;
  2244.         break;
  2245.  
  2246.       case PMSGID_OPEN:
  2247.         NewTN->tn_ID = TN->tn_ID;
  2248.         NewTN->tn_FH = TN->tn_FH;
  2249.         NewTN->tn_FHMode = TN->tn_FHMode;
  2250.         NewTN->tn_FHName = MEM_StrToVec(TN->tn_FHName);
  2251.         if (TN->tn_CurDirName)
  2252.           if (!(TN->tn_CurDirName = MEM_StrToVec(TN->tn_CurDirName)))
  2253.             break;
  2254.  
  2255.         if (NewTN->tn_FHName) Success = TRUE;
  2256.         break;
  2257.  
  2258.       case PMSGID_OPENFROMLOCK:
  2259.         NewTN->tn_ID = NewTN->tn_ID;
  2260.         NewTN->tn_Lock = TN->tn_Lock;
  2261.         NewTN->tn_FH = TN->tn_FH;
  2262.         NewTN->tn_FHName = MEM_StrToVec(TN->tn_FHName);
  2263.         if (TN->tn_CurDirName)
  2264.           if (!(TN->tn_CurDirName = MEM_StrToVec(TN->tn_CurDirName)))
  2265.             break;
  2266.         if (NewTN->tn_FHName) Success = TRUE;
  2267.         break;
  2268.     }
  2269.   } 
  2270.   if (!Success)
  2271.   {
  2272.     ARTL_FreeTN(NewTN); NewTN = NULL;
  2273.   }
  2274.   return NewTN;
  2275. }
  2276.  
  2277. LPROTO BOOL ATRL_BuildTNPath( struct TrackerNode *TN )
  2278. {
  2279.   /*********************************************************************
  2280.    *
  2281.    * ATRL_BuildTNPath()
  2282.    *
  2283.    * The routine makes sure that the Name field of a file related
  2284.    * TrackerNode is a full path. This is done by joining the
  2285.    * TN->tn_CurDirName and name fields.
  2286.    *
  2287.    * Normally this routine is called after a TrackerNode has been
  2288.    * freshly created.
  2289.    *
  2290.    *********************************************************************
  2291.    *
  2292.    */
  2293.  
  2294.   #define TMP_BUF_LEN 512
  2295.  
  2296.   UBYTE **NamePart = NULL;
  2297.   UBYTE TmpPath[TMP_BUF_LEN + 2];
  2298.  
  2299.   if (!TN) return FALSE;
  2300.   if (!TN->tn_CurDirName) return TRUE;
  2301.     
  2302.   switch(TN->tn_ID)
  2303.   {
  2304.     case PMSGID_OPEN:
  2305.       NamePart = (UBYTE **) &TN->tn_FHName;   break;
  2306.     case PMSGID_OPENFROMLOCK:
  2307.       NamePart = (UBYTE **) &TN->tn_FHName;   break;
  2308.     case PMSGID_LOCK:
  2309.       NamePart = (UBYTE **) &TN->tn_LockName; break;
  2310.     default:
  2311.       return TRUE;
  2312.   }
  2313.   
  2314.   if (!NamePart || !*NamePart) return FALSE;  
  2315.   strcpy((UBYTE *)&TmpPath, TN->tn_CurDirName);
  2316.  
  2317.   if (!AddPart((UBYTE *)&TmpPath, FilePart(*NamePart), TMP_BUF_LEN))
  2318.     return FALSE;
  2319.  
  2320.   MEM_FreeVec(*NamePart);
  2321.   *NamePart = MEM_StrToVec((UBYTE *)&TmpPath);
  2322.  
  2323.   if (*NamePart) return TRUE; else return FALSE;  
  2324. }
  2325.  
  2326. /* Note: The following ARTL_Find#? routines will always ignore
  2327.          TrackerNodes that are not in use. This is to avoid the
  2328.          chance that a clash will happen if two resources ever
  2329.          share the same memory space (at different times). For
  2330.          example, if task "A" closes a filehandle then task "B"
  2331.          opens a new filehandle, it's possible that the new
  2332.          filehandle will share the same memory space as the old
  2333.          one, even though they are two separate file handles. */
  2334.  
  2335. LPROTO struct TrackerNode *ARTL_FindLibTN_ViaLibName( struct List *TL,
  2336.   UBYTE *LibName )
  2337. {
  2338.   /*********************************************************************
  2339.    *
  2340.    * ARTL_FindLibTN_ViaLibName()
  2341.    *
  2342.    * Find a TrackerNode in a TrackerList via a library name.
  2343.    *
  2344.    *********************************************************************
  2345.    *
  2346.    */
  2347.  
  2348.   register struct TrackerNode *TN;
  2349.   
  2350.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2351.        TN->tn_Node.ln_Succ ;
  2352.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2353.   {
  2354.     if ((TN->tn_ID == PMSGID_OPENLIBRARY) &&
  2355.         (Stricmp(LibName, TN->tn_LibName) == 0) &&
  2356.          TN->tn_InUse)
  2357.     {
  2358.       return TN;
  2359.     }
  2360.   }
  2361.   return NULL;
  2362. }
  2363.  
  2364. LPROTO struct TrackerNode *ARTL_FindLibTN_ViaLibBase( struct List *TL,
  2365.   struct Library *LibBase )
  2366. {
  2367.   /*********************************************************************
  2368.    *
  2369.    * ARTL_FindLibTN_ViaLibBase()
  2370.    *
  2371.    * Find a TrackerNode in a TrackerList via a library base pointer.
  2372.    *
  2373.    *********************************************************************
  2374.    *
  2375.    */
  2376.  
  2377.   register struct TrackerNode *TN;
  2378.   
  2379.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2380.        TN->tn_Node.ln_Succ ;
  2381.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2382.   {
  2383.     if ((TN->tn_ID == PMSGID_OPENLIBRARY) &&
  2384.         (LibBase == TN->tn_LibBase) &&
  2385.         TN->tn_InUse)
  2386.     {
  2387.       return TN;
  2388.     }
  2389.   }
  2390.   return NULL;
  2391. }
  2392.  
  2393. LPROTO struct TrackerNode *ARTL_FindDevTN_ViaIOReq( struct List *TL,
  2394.   struct IORequest *IOReq )
  2395. {
  2396.   /*********************************************************************
  2397.    *
  2398.    * ARTL_FindDevTN_ViaIOReq()
  2399.    *
  2400.    * Find a TrackerNode in a TrackerList via a device IORequest pointer.
  2401.    *
  2402.    *********************************************************************
  2403.    *
  2404.    */
  2405.  
  2406.   register struct TrackerNode *TN;
  2407.   
  2408.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2409.        TN->tn_Node.ln_Succ;
  2410.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2411.   {
  2412.     if ((TN->tn_ID == PMSGID_OPENDEVICE) &&
  2413.         (IOReq == TN->tn_DevIOReq) &&
  2414.         TN->tn_InUse)
  2415.     {
  2416.       return TN;
  2417.     }
  2418.   }
  2419.   return NULL;
  2420. }
  2421.  
  2422. LPROTO struct TrackerNode *ARTL_FindDevTN_ViaDevName( struct List *TL,
  2423.   UBYTE *DevName )
  2424. {
  2425.   /*********************************************************************
  2426.    *
  2427.    * FindDevTN_Devname()
  2428.    *
  2429.    * Find a TrackerNode in a TrackerList via Device name.
  2430.    *
  2431.    *********************************************************************
  2432.    *
  2433.    */
  2434.  
  2435.   register struct TrackerNode *TN;
  2436.   
  2437.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2438.        TN->tn_Node.ln_Succ;
  2439.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2440.   {
  2441.     if ((TN->tn_ID == PMSGID_OPENDEVICE) &&
  2442.         (Stricmp(DevName, TN->tn_DevName) == 0) &&
  2443.         TN->tn_InUse)
  2444.     {
  2445.       return TN;
  2446.     }
  2447.   }
  2448.   return NULL;
  2449. }
  2450.  
  2451. LPROTO struct TrackerNode *ARTL_FindFontTN_ViaTextFont( struct List *TL,
  2452.   struct TextFont *TF )
  2453. {
  2454.   /*********************************************************************
  2455.    *
  2456.    * ARTL_FindFontTN_ViaTextFont()
  2457.    *
  2458.    *********************************************************************
  2459.    *
  2460.    */
  2461.  
  2462.   register struct TrackerNode *TN;
  2463.   
  2464.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2465.        TN->tn_Node.ln_Succ;
  2466.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2467.   {
  2468.     if (TN->tn_ID == PMSGID_OPENFONT)
  2469.     {
  2470.       if (TF == TN->tn_FontTextFont && TN->tn_InUse) return TN;
  2471.     }
  2472.   }
  2473.   return NULL;  
  2474. }
  2475.  
  2476. LPROTO struct TrackerNode *ARTL_FindLockTN_ViaLock( struct List *TL,
  2477.   BPTR Lk )
  2478. {
  2479.   /*********************************************************************
  2480.    *
  2481.    * ARTL_FindLockTN_ViaLock()
  2482.    *
  2483.    *********************************************************************
  2484.    *
  2485.    */
  2486.  
  2487.   register struct TrackerNode *TN;
  2488.   
  2489.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2490.        TN->tn_Node.ln_Succ;
  2491.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2492.   {
  2493.     if (TN->tn_ID == PMSGID_LOCK)
  2494.     {
  2495.       if (Lk == TN->tn_Lock && TN->tn_InUse) return TN;
  2496.     }
  2497.   }
  2498.   return NULL;      
  2499. }
  2500.  
  2501. LPROTO struct TrackerNode *ARTL_FindFileHandleTN_ViaFH( struct List *TL,
  2502.   BPTR FH )
  2503. {
  2504.   /*********************************************************************
  2505.    *
  2506.    * ARTL_FindFileHandleTN_ViaFH()
  2507.    *
  2508.    *********************************************************************
  2509.    *
  2510.    */
  2511.  
  2512.   register struct TrackerNode *TN;
  2513.   
  2514.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2515.        TN->tn_Node.ln_Succ;
  2516.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2517.   {
  2518.     if ((TN->tn_ID == PMSGID_OPEN) || (TN->tn_ID == PMSGID_OPENFROMLOCK))
  2519.     {
  2520.       if (FH == TN->tn_FH && TN->tn_InUse) return TN;
  2521.     }
  2522.   }
  2523.   return NULL;      
  2524. }
  2525.  
  2526. LPROTO void ARTL_UnlinkTN( struct TrackerNode *TN )
  2527. {
  2528.   /*********************************************************************
  2529.    *
  2530.    * ARTL_UnlinkTN()
  2531.    *
  2532.    * Unlink a TrackerNode from a TrackerList.
  2533.    *
  2534.    *********************************************************************
  2535.    *
  2536.    */
  2537.  
  2538.   if ((TN->tn_Node.ln_Succ == NULL) || (TN->tn_Node.ln_Pred == NULL))
  2539.     return;
  2540.   Remove((struct Node *)TN);
  2541.   TN->tn_Node.ln_Succ = NULL;
  2542.   TN->tn_Node.ln_Pred = NULL;
  2543. }
  2544.  
  2545. LPROTO void ARTL_FreeTL( struct List *TL )
  2546. {
  2547.   /*********************************************************************
  2548.    *
  2549.    * ARTL_FreeTL()
  2550.    *
  2551.    * Free an entire TrackerList.
  2552.    *
  2553.    *********************************************************************
  2554.    *
  2555.    */
  2556.  
  2557.   register struct TrackerNode *TN, *TmpTN;
  2558.   
  2559.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2560.        TN->tn_Node.ln_Succ ;)
  2561.   {
  2562.     TmpTN = (struct TrackerNode *) TN->tn_Node.ln_Succ;
  2563.     ARTL_FreeTN(TN); TN = TmpTN;
  2564.   }
  2565.   NewList(TL);  
  2566. }
  2567.  
  2568. LPROTO void ARTL_UpdateTL( struct List *TL )
  2569. {
  2570.   /*********************************************************************
  2571.    *
  2572.    * ARTL_UpdateTL()
  2573.    *
  2574.    * Update the GUI tracker lister using a TrackerLister structure.
  2575.    *
  2576.    *********************************************************************
  2577.    *
  2578.    */
  2579.  
  2580.   register struct TrackerNode *TN;
  2581.   register ULONG TrackMode = ARTL_Get_TrackMode();
  2582.  
  2583.   GUI_Act_List_Clear(OID_MAIN_TRACKERLIST);
  2584.   GUI_Set_List_Quiet(OID_MAIN_TRACKERLIST, TRUE);
  2585.  
  2586.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2587.        TN->tn_Node.ln_Succ;
  2588.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2589.   { 
  2590.     if (cfg_ShowUnusedResources == FALSE && TN->tn_InUse == FALSE)
  2591.       continue;
  2592.  
  2593.     if (TrackMode == TRACKMODE_LIBRARIES && TN->tn_ID == PMSGID_OPENLIBRARY)
  2594.       GUI_Act_List_InsertABC(OID_MAIN_TRACKERLIST, TN);
  2595.     else if (TrackMode == TRACKMODE_DEVICES && TN->tn_ID == PMSGID_OPENDEVICE)
  2596.       GUI_Act_List_InsertABC(OID_MAIN_TRACKERLIST, TN);
  2597.     else if (TrackMode == TRACKMODE_FONTS && (TN->tn_ID == PMSGID_OPENFONT))
  2598.       GUI_Act_List_InsertABC(OID_MAIN_TRACKERLIST, TN);
  2599.     else if ((TrackMode == TRACKMODE_FILEHANDLES) &&
  2600.               (TN->tn_ID == PMSGID_OPEN) || (TN->tn_ID == PMSGID_OPENFROMLOCK))
  2601.       GUI_Act_List_InsertABC(OID_MAIN_TRACKERLIST, TN);
  2602.     else if (TrackMode == TRACKMODE_LOCKS && TN->tn_ID == PMSGID_LOCK)
  2603.       GUI_Act_List_InsertABC(OID_MAIN_TRACKERLIST, TN);
  2604.   }
  2605.   GUI_Set_List_Quiet(OID_MAIN_TRACKERLIST, FALSE);
  2606. }
  2607.  
  2608. LPROTO ULONG ARTL_CountTL( struct List *TL, LONG ID )
  2609. {
  2610.   /*********************************************************************
  2611.    *
  2612.    * ARTL_CountTL()
  2613.    *
  2614.    * Count the amount of TrackerNodes in a TrackerList, using a
  2615.    * specific AppNode ID. Use PMSGID_ALL to count all nodes.
  2616.    *
  2617.    * Notes
  2618.    * -----
  2619.    *
  2620.    * You may pass PMSGID_ALL to the ID parameter.
  2621.    *
  2622.    *********************************************************************
  2623.    *
  2624.    */
  2625.  
  2626.   register struct TrackerNode *TN;
  2627.   register ULONG Cnt = 0;
  2628.   
  2629.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2630.        TN->tn_Node.ln_Succ;
  2631.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2632.   {
  2633.     if ((TN->tn_ID == ID) || (ID == PMSGID_ALL)) Cnt++;
  2634.   }
  2635.   return Cnt;
  2636. }
  2637.  
  2638. LPROTO ULONG ARTL_CountTNsInUse( struct List *TL )
  2639. {
  2640.   /*********************************************************************
  2641.    *
  2642.    * ARTL_CountTNsInUse()
  2643.    *
  2644.    * Count the amount of TrackerNodes in a TrackerList that
  2645.    * currently have their TrackerNodes->tn_InUse flag set.
  2646.    *
  2647.    *********************************************************************
  2648.    *
  2649.    */
  2650.  
  2651.   register ULONG Cnt = 0;
  2652.   register struct TrackerNode *TN;
  2653.  
  2654.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2655.        TN->tn_Node.ln_Succ;
  2656.        TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2657.   {
  2658.     if (TN->tn_InUse) Cnt++;
  2659.   }
  2660.   return Cnt;
  2661. }
  2662.  
  2663. GPROTO ULONG ARTL_ClearUnusedTNs( struct List *TL )
  2664. {
  2665.   /*********************************************************************
  2666.    *
  2667.    * ARTL_ClearUnusedTNs()
  2668.    *
  2669.    *********************************************************************
  2670.    *
  2671.    */
  2672.  
  2673.   register ULONG FreedTNCnt = 0;
  2674.   register struct TrackerNode *TN, *NextTN;
  2675.  
  2676.   for (TN = (struct TrackerNode *) TL->lh_Head;
  2677.        TN->tn_Node.ln_Succ;)
  2678.   {
  2679.     NextTN = (struct TrackerNode *) TN->tn_Node.ln_Succ;
  2680.     
  2681.     if (!TN->tn_InUse)
  2682.     {
  2683.       ARTL_UnlinkTN(TN); ARTL_FreeTN(TN);
  2684.       FreedTNCnt++;
  2685.     }   
  2686.     TN = NextTN;
  2687.   }
  2688.   return FreedTNCnt;
  2689. }
  2690.  
  2691.  
  2692. /**** ATRL misc ************************************************************/
  2693.  
  2694. LPROTO void ARTL_FindAppsUsingRes( struct TrackerNode *TNToFnd,
  2695.   struct AppList *AL )
  2696. {
  2697.   /*********************************************************************
  2698.    *
  2699.    * ARTL_FindAppsUsingRes()
  2700.    *
  2701.    * This routine will try to locate all AppNodes using a particular
  2702.    * resource. This resource is represented by the TrackerNode
  2703.    * structure. The details of the resulting AppNodes are inserted into
  2704.    * the "APPUSING" lister.
  2705.    *
  2706.    *********************************************************************
  2707.    *
  2708.    */
  2709.  
  2710.   register struct AppNode *AN;
  2711.  
  2712.   ARTL_LockAL(AL);
  2713.  
  2714.   for (AN = (struct AppNode *) ARTL->al_List.lh_Head;
  2715.        AN->an_Node.ln_Succ;
  2716.        AN = (struct AppNode *) AN->an_Node.ln_Succ)
  2717.   {
  2718.     register struct TrackerNode *TN;
  2719.  
  2720.     for (TN = (struct TrackerNode *) AN->an_TrackerList.lh_Head;
  2721.          TN->tn_Node.ln_Succ;
  2722.          TN = (struct TrackerNode *) TN->tn_Node.ln_Succ)
  2723.     {
  2724.       if ((TNToFnd->tn_ID == TN->tn_ID) && TN->tn_InUse)
  2725.       {
  2726.         register LONG CmpResult = -1;
  2727.  
  2728.         switch(TN->tn_ID)
  2729.         {
  2730.           case PMSGID_OPENLIBRARY:
  2731.             CmpResult = Stricmp(TNToFnd->tn_LibName, TN->tn_LibName);
  2732.             break;
  2733.           case PMSGID_OPENDEVICE:
  2734.             CmpResult = Stricmp(TNToFnd->tn_DevName, TN->tn_DevName);
  2735.             break;
  2736.           case PMSGID_OPENFONT:
  2737.             CmpResult = Stricmp(TNToFnd->tn_FontName, TN->tn_FontName);
  2738.             break;
  2739.  
  2740.           case PMSGID_OPENFROMLOCK:
  2741.           case PMSGID_OPEN:
  2742.           {
  2743.             CmpResult = -1; /* Assume they're different */
  2744.  
  2745.             if (TNToFnd->tn_FHName && TN->tn_FHName)
  2746.             {
  2747.               register BPTR Lock1 = 0, Lock2 = 0;
  2748.                             
  2749.               if ((Lock1 = Lock(TNToFnd->tn_FHName, SHARED_LOCK)) &&
  2750.                   (Lock2 = Lock(TN->tn_FHName, SHARED_LOCK)))
  2751.               {
  2752.                 if (SameLock(Lock1, Lock2) == LOCK_SAME) CmpResult = 0;
  2753.               }   
  2754.               if (Lock1) UnLock(Lock1);
  2755.               if (Lock2) UnLock(Lock2);             
  2756.             }
  2757.             break;
  2758.           }
  2759.  
  2760.           case PMSGID_LOCK:
  2761.           {
  2762.             CmpResult = -1; /* Assume they're different */
  2763.  
  2764.             if (TNToFnd->tn_LockName && TN->tn_LockName)
  2765.             {
  2766.               register BPTR Lock1 = 0, Lock2 = 0;
  2767.                             
  2768.               if ((Lock1 = Lock(TNToFnd->tn_FHName, SHARED_LOCK)) &&
  2769.                   (Lock2 = Lock(TN->tn_FHName, SHARED_LOCK)))
  2770.               {
  2771.                 if (SameLock(Lock1, Lock2) == LOCK_SAME) CmpResult = 0;
  2772.               }
  2773.               if (Lock1) UnLock(Lock1);
  2774.               if (Lock2) UnLock(Lock2);             
  2775.             }
  2776.             break;
  2777.           }
  2778.         }
  2779.           
  2780.         if (CmpResult == 0)
  2781.         {
  2782.           register UBYTE *AppName = AN->an_CmdName;
  2783.           if (!AppName) AppName = AN->an_TaskName;
  2784.           GUI_Act_List_InsertABC(OID_APPUSING_LISTVIEW, FilePart(AppName));
  2785.         }
  2786.       }
  2787.     } /* for(;;) */
  2788.   } /* for(;;) */
  2789.   ARTL_UnlockAL(AL);
  2790. }
  2791.  
  2792. LPROTO ULONG ARTL_CountList( struct List *L )
  2793. {
  2794.   /*********************************************************************
  2795.    *
  2796.    * ARTL_CountList()
  2797.    *
  2798.    * A generic list node count function. Suitable for all exec style
  2799.    * linked lists.
  2800.    *
  2801.    *********************************************************************
  2802.    *
  2803.    */
  2804.  
  2805.   register struct Node *N;
  2806.   register ULONG Cnt = 0;
  2807.  
  2808.   for (N = L->lh_Head; N->ln_Succ; N = N->ln_Succ)
  2809.     Cnt++;
  2810.   return Cnt;
  2811. }
  2812.  
  2813. /***************************************************************************/
  2814. /* Hooks for the left lister (aka AppLister) */
  2815. /***************************************************************************/
  2816.  
  2817. GPROTO void ARTL_AppListKillFunc( register __a2 APTR Pool,
  2818.   register __a1 struct AppNode *AN )
  2819. {
  2820.   ARTL_FreeAN(AN);
  2821. }
  2822.  
  2823. GPROTO struct AppNode *ARTL_AppListMakeFunc( register __a2 APTR Pool,
  2824.   register __a1 struct AppNode *AN )
  2825. {
  2826.   return ARTL_CloneAN(AN); /* Clone the AppNode */
  2827. }
  2828.  
  2829. GPROTO LONG ARTL_AppListShowFunc( register __a2 UBYTE **ColumnArray,
  2830.   register __a1 struct AppNode *AN )
  2831. { 
  2832.   if (AN)
  2833.   {
  2834.     ColumnArray[0] = AN->an_TaskName;
  2835.  
  2836.     if (AN->an_CmdName) ColumnArray[0] = AN->an_CmdName;
  2837.  
  2838.     if (ColumnArray[0][0] == 0)
  2839.       ColumnArray[0] = "(Internal Error: Hook got empty string)";
  2840.     else if (cfg_RemovePaths)
  2841.       ColumnArray[0] = FilePart(ColumnArray[0]);
  2842.  
  2843.     switch(AN->an_TaskType)
  2844.     {
  2845.       case NT_TASK:    ColumnArray[1] = STR_Get(SID_TASK);    break;
  2846.       case NT_PROCESS: ColumnArray[1] = STR_Get(SID_PROCESS); break;
  2847.       default:         ColumnArray[1] = STR_Get(SID_UNKNOWN); break;
  2848.     }
  2849.  
  2850.     switch(AN->an_Status)
  2851.     {
  2852.       default:
  2853.       case AN_STATUS_UNKNOWN: ColumnArray[2] = STR_Get(SID_UNKNOWN); break;
  2854.       case AN_STATUS_ALIVE:   ColumnArray[2] = STR_Get(SID_ALIVE);   break;
  2855.       case AN_STATUS_DEAD:    ColumnArray[2] = STR_Get(SID_DEAD);    break;
  2856.     }
  2857.   }
  2858.   else
  2859.   {
  2860.     ColumnArray[0] = STR_Get(SID_APPNAME);
  2861.     ColumnArray[1] = STR_Get(SID_TYPE);
  2862.     ColumnArray[2] = STR_Get(SID_STATUS);
  2863.   }
  2864.   return 0;
  2865. }
  2866.  
  2867. GPROTO LONG ARTL_AppListSortFunc( register __a1 struct AppNode *AN1,
  2868.   register __a2 struct AppNode *AN2 )
  2869. {
  2870.   return Stricmp(AN1->an_TaskName, AN2->an_TaskName);
  2871. }
  2872.  
  2873. struct Hook ARTL_AppListMakeHook =
  2874.   { { NULL, NULL }, (void *) ARTL_AppListMakeFunc, NULL, NULL };
  2875. struct Hook ARTL_AppListKillHook =
  2876.   { { NULL, NULL }, (void *) ARTL_AppListKillFunc, NULL, NULL };
  2877. struct Hook ARTL_AppListShowHook =
  2878.   { { NULL, NULL }, (void *) ARTL_AppListShowFunc, NULL, NULL };
  2879. struct Hook ARTL_AppListSortHook =
  2880.   { { NULL, NULL }, (void *) ARTL_AppListSortFunc, NULL, NULL };
  2881.  
  2882. /***************************************************************************/
  2883. /* Hooks for the right lister (aka TrackerLister) */
  2884. /***************************************************************************/
  2885.  
  2886. GPROTO void ARTL_TrackerListKillFunc( register __a2 APTR Pool,
  2887.   register __a1 struct TrackerNode *TN )
  2888. {
  2889.   ARTL_FreeTN(TN); /* Free the clone allocated by the make hook. */
  2890. }
  2891.  
  2892. GPROTO struct TrackerNode *ARTL_TrackerListMakeFunc(
  2893.   register __a2 APTR Pool,
  2894.   register __a1 struct TrackerNode *TN )
  2895. {
  2896.   /* We must clone the tracker node so the ARTL-Handler doesn't
  2897.      rip the memory from under MUI. */
  2898.   
  2899.   return ARTL_CloneTN(TN);
  2900. }
  2901.  
  2902. GPROTO LONG ARTL_TrackerListShowFunc( register __a2 UBYTE **ColumnArray,
  2903.   register __a1 struct TrackerNode *TN )
  2904. {
  2905.   if (TN)
  2906.   {
  2907.     sprintf((UBYTE *) &TN->tn_OpenCntTxt, "%ld", TN->tn_OpenCnt);
  2908.     ColumnArray[1] = (UBYTE *) &TN->tn_OpenCntTxt;
  2909.  
  2910.     switch(TN->tn_ID)
  2911.     {
  2912.       case PMSGID_OPENLIBRARY:
  2913.         ColumnArray[0] = TN->tn_LibName;
  2914.         break;
  2915.       case PMSGID_OPENDEVICE:
  2916.         sprintf((UBYTE *)&TN->tn_DevUnitNumTxt, "%ld", TN->tn_DevUnitNum);
  2917.         ColumnArray[0] = TN->tn_DevName;
  2918.         ColumnArray[1] = (UBYTE *) &TN->tn_DevUnitNumTxt;
  2919.         break;
  2920.       case PMSGID_OPENFONT:
  2921.         ColumnArray[0] = TN->tn_FontName;
  2922.         break;
  2923.  
  2924.       case PMSGID_OPENFROMLOCK:
  2925.       case PMSGID_OPEN:
  2926.       {
  2927.         if (!TN->tn_FHName || strlen(TN->tn_FHName) == 0)
  2928.           ColumnArray[0] = "(no name)";
  2929.         else
  2930.           ColumnArray[0] = TN->tn_FHName;
  2931.  
  2932.         switch(TN->tn_FHMode)
  2933.         {
  2934.           case MODE_OLDFILE:   ColumnArray[1] = "Read";       break;
  2935.           case MODE_NEWFILE:   ColumnArray[1] = "Write";      break;
  2936.           case MODE_READWRITE: ColumnArray[1] = "Read/Write"; break;
  2937.           default:             ColumnArray[1] = "Unknown";    break;
  2938.         }       
  2939.         break;
  2940.       }
  2941.  
  2942.       case PMSGID_LOCK:
  2943.       {
  2944.         if (!TN->tn_LockName || strlen(TN->tn_LockName) == 0)
  2945.           ColumnArray[0] = "(no name)";
  2946.         else
  2947.           ColumnArray[0] = TN->tn_LockName;
  2948.  
  2949.         switch(TN->tn_LockMode)
  2950.         {
  2951.           case SHARED_LOCK:    ColumnArray[1] = "Shared";    break;
  2952.           case EXCLUSIVE_LOCK: ColumnArray[1] = "Exclusive"; break;
  2953.           default:             ColumnArray[1] = "Unknown";   break;
  2954.         }       
  2955.         break;
  2956.       }
  2957.  
  2958.       default:
  2959.         ColumnArray[0] = "Internal Error: Unknown Trackernode ID!";
  2960.         break;
  2961.     }
  2962.  
  2963.     if (TN->tn_InUse) ColumnArray[2] = "Yes";
  2964.     else ColumnArray[2] = "No";
  2965.   }
  2966.   else  /* Print lister title */
  2967.   {       
  2968.     switch(ARTL_Get_TrackMode())
  2969.     {
  2970.       case TRACKMODE_LIBRARIES:
  2971.         ColumnArray[0] = STR_Get(SID_LISTTITLE_LIBRARIES);
  2972.         ColumnArray[1] = STR_Get(SID_LISTTITLE_OPENCOUNT);
  2973.         ColumnArray[2] = "\33bIn use?";
  2974.         break;
  2975.       case TRACKMODE_DEVICES:
  2976.         ColumnArray[0] = STR_Get(SID_LISTTITLE_DEVICES);
  2977.         ColumnArray[1] = "\33bUnit Num";
  2978.         ColumnArray[2] = "\33bIn use?";
  2979.         break;
  2980.       case TRACKMODE_FONTS:
  2981.         ColumnArray[0] = STR_Get(SID_LISTTITLE_FONTS);
  2982.         ColumnArray[1] = STR_Get(SID_LISTTITLE_OPENCOUNT);
  2983.         ColumnArray[2] = "\33bIn use?";
  2984.         break;
  2985.       case TRACKMODE_FILEHANDLES:
  2986.         ColumnArray[0] = "\33bFile handles";
  2987.         ColumnArray[1] = "\33bMode";
  2988.         ColumnArray[2] = "\33bIn use?";
  2989.         break;
  2990.       case TRACKMODE_LOCKS:
  2991.         ColumnArray[0] = "\33bLocks";
  2992.         ColumnArray[1] = "\33bMode";
  2993.         ColumnArray[2] = "\33bIn use?";
  2994.         break;
  2995.       default:
  2996.         ColumnArray[0] = "\33bInternal Error: Unknown TrackMode ID!!!";
  2997.         ColumnArray[1] = "";
  2998.         ColumnArray[2] = "";
  2999.         break;
  3000.     }
  3001.  
  3002.   }
  3003.   return 0;
  3004. }
  3005.  
  3006. GPROTO LONG ARTL_TrackerListSortFunc(
  3007.   register __a1 struct TrackerNode *TN1,
  3008.   register __a2 struct TrackerNode *TN2 )
  3009. {
  3010.   register LONG result;
  3011.  
  3012.   switch(TN1->tn_ID)
  3013.   {
  3014.     case PMSGID_OPENLIBRARY:
  3015.       result = Stricmp(TN1->tn_LibName, TN2->tn_LibName);
  3016.       break;
  3017.     case PMSGID_OPENDEVICE:
  3018.       result = Stricmp(TN1->tn_DevName, TN2->tn_DevName);
  3019.       break;
  3020.     case PMSGID_OPENFONT:
  3021.       result = Stricmp(TN1->tn_FontName, TN2->tn_FontName);
  3022.       break;
  3023.     default:
  3024.       result = 0;
  3025.       break;
  3026.   }
  3027.   return result; 
  3028. }
  3029.  
  3030. struct Hook ARTL_TrackerListMakeHook =
  3031.   { { NULL, NULL }, (void *) ARTL_TrackerListMakeFunc, NULL, NULL };
  3032. struct Hook ARTL_TrackerListKillHook =
  3033.   { { NULL, NULL }, (void *) ARTL_TrackerListKillFunc, NULL, NULL };
  3034. struct Hook ARTL_TrackerListShowHook =
  3035.   { { NULL, NULL }, (void *) ARTL_TrackerListShowFunc, NULL, NULL };
  3036. struct Hook ARTL_TrackerListSortHook =
  3037.   { { NULL, NULL }, (void *) ARTL_TrackerListSortFunc, NULL, NULL };
  3038.  
  3039.   /*********************************************************************
  3040.    *
  3041.    *
  3042.    *
  3043.    *********************************************************************
  3044.    *
  3045.    */
  3046.  
  3047.  
  3048.